^-^
一个后知后觉的追赶者
Go 快速入门（二）
最近更新：2025-02-22   |   字数总计：2.9k   |   阅读估时：12分钟   |   阅读量：次

本文的内容建立在已对 C 和 C++ 熟练掌握的基础之上，主要给出 Go 与 C 和 C++ 之间的不同之处。

复杂数据类型

复数

复数类型支持两种赋值操作及各种运算操作，示例如下。

1
2
3
4
5
6
7
8
c1 := complex(1, 2)
c2 := 3 + 4i
fmt.Println(c1 + c2) // -> 4 + 6i
fmt.Println(c1 - c2) // -> -2 - 2i
fmt.Println(c1 * c2) // -> -5 + 10i
fmt.Println(c1 / c2) // -> 0.44 + 0.88i
c1++
fmt.Println(c1) // -> 2 + 2i

运算操作符不支持 %（取模），关系操作符仅支持 == 及 !=，不支持逻辑运算符及位运算符。

复数类型使用 real() 和 imag() 可以获取取实部与虚部，复数可以转换为浮点类型，示例如下。

1
2
c := complex(1, 2)
fmt.Println(real(c), imag(c)) // 1 2

复数类型一旦创建无法直接进行修改，若想修改只能创建一个新的复数。

数组

数组声明时必须指明大小，以下是几种数组的声明方法。

1
2
3
4
5
var nums [10]int
var nums = [10]int{1, 2, 3, 4, 5}
nums := [10]int{1, 2, 3, 4, 5}
nums := [...]int{1, 2, 3, 4, 5}
nums := [10]int{1: 3, 2: 4}

第一种是数组的最基本声明方式 var nums [size]type，创建了一个长度为 10 的 int 型数组，其中的数值全部初始化为 0；第二种声明方式不明确指明变量类型，由 Go 进行推断，数组仅对前 5 个元素指明数值，其他元素初始化为 0；第三种为第二种的简明声明方式；第四种声明方式不指明数组长度，由 Go 根据数组元素数量进行推断，得到一个长度为 5 的数组；第五种根据索引对数组的某些特定位置进行赋值，将 nums[1] 和 nums[2] 分别赋值为 3 和 4，其他元素默认为 0。

多维数组的声明方式类似于一维数组，示例如下。

1
2
3
4
5
6
7
8
var nums = [2][4]int {
  {1, 2, 3, 4},
  {5, 6, 7, 8},
}
nums := [2][4]int {
  {1, 2, 3, 4},
  {5, 6, 7, 8},
}

切片

切片的本质

切片和数组很像，但是有着本质上的不同。数组在声明时需要明确指明大小，而切片是对数组的一个 引用，其实际为一个结构体，包含有切片的基址、长度和容量。长度为当前切片中实际存储的成员数量，容量则是最大可容纳的成员数量。下面是一个小实验，验证切片的结构。

1
2
3
4
5
nums := [10]int{1, 2, 3, 4, 5}
fmt.Println(unsafe.Sizeof(nums)) // -> 80

slice := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
fmt.Println(unsafe.Sizeof(slice)) // -> 24

上面的实验可以发现，数组正常占用了 10 个元素的容量，但是切片仅占用了三个 int 型的容量，对应到了基址、长度及容量的结构体。

切片的定义

基于切片是对数组引用的思想，以下是切片的几种定义方式。

1
2
3
4
5
6
var slice []int
var slice []int = make([]int, len)
var slice []int = make([]int, len, cap)
slice := []int{1, 2, 3}
slice := arr[start:end:max]
subslice := slice[start:end]

第一种是最基本的切片定义方式，定义了一个 nil（空）切片；第二种和第三种指定了切片的长度和容量；第四种直接指明了切片引用的数组；第五种创建时引用 arr 数组中的元素 arr[start, end)，并设定了底层引用最大位置为 max；第六种创建了一个切片的子切片，其也是对切片的引用。

二维切片的创建方式类似于一维切片，示例如下。

1
2
3
4
nums := [][]int{
  {1, 2, 3},
  {4, 5, 6},
}

切片的函数

切片可用的函数有 len()（取长度），cap()（取容量），append()（追加），copy()（复制），使用方式如下。

1
2
3
4
5
6
7
8
9
slice1 := make([]int, 3, 10)
fmt.Println(slice1, len(slice1), cap(slice1)) // -> [0 0 0] 3 10

slice1 = append(slice1, 1, 2, 3) // 多个追加
fmt.Println(slice1, len(slice1), cap(slice1)) // -> [0 0 0 1 2 3] 5 10

slice2 := make([]int, 4, 20)
copy(slice2, slice1)
fmt.Println(slice2, len(slice2), cap(slice2)) // -> [0 0 0 1] 4 20

特别注意，切片是对原数组的引用，那么对切片的任何修改都会反映到原数组上，以下是一个例子。

1
2
3
4
5
6
arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4]
fmt.Println(slice, len(slice), cap(slice)) // -> [2 3 4] 3 4

slice = append(slice, 1)
fmt.Println(arr) // -> [1 2 3 4 1]

这里的 cap(slice) = 4 原因是切片的最大容量是由底层引用的数组所限制，切片的最大容量是由切片起始点到引用的数组最大位置决定。

当 append() 操作使容量超出限制时，切片会重新初始化一个引用的底层数组，容量倍增，此时的切片和原数组不再存在关联。

字符串

字符串的底层实现实际为一个结构体，包含有字符串基址及字符串长度，基址中存放 byte 型数组。Go 中的字符串一经创建无法直接修改。

为了修改字符串，需要对字符串创建切片，然后对切片进行修改，示例如下。

1
2
3
4
5
6
var str string = "Hello World"
s1 := str[1:5] // 错误，这不是一个切片操作，会返回一个 string
s2 := []byte(str) // 正确
s2[0] = 'G'
str = string(s2);
fmt.Println(str) // -> Gello World

对于 UTF-8 字符串需要使用 []rune() 进行切片。仔细阅读上面的代码不难发现，就算是使用了切片修改字符串，最后还是需要将切片转换为字符串赋回原串，所以本质上是用一个新的字符串替代了原字符串。这里的原因是，字符串创建切片时用的是 str 的一个副本，而对于 []int 的切片使用的是对底层数组的引用。

字符串也可以使用 len() 函数，以下是示例。

1
2
3
str1 := "Hello"
str2 := "你好"
fmt.Println(len(str1), len(str2)) -> 5 6

不难发现，字符串的 len() 实际上求的是所占 byte 数量。

字符串支持 + 运算。

1
2
3
str1 := "hello"
str2 := "world"
fmt.Println(str1 + " " + str2) // hello world

多行字符串的定义方式如下。

1
2
3
str := `the first line
the second line
the third line`

集合

集合 map 是指无序的键值对集合，可以类比为 C 中的哈希表 unordered_map。集合的定义方式如下。

1
2
3
4
5
6
m := make(map[string]int, 10)
m := map[string]int{
  "apple": 10,
  "banana": 2,
  "pineapple": 5,
}

第一种定义方法将 string 置为键，int 置为值，设定了一个大小为 10 的集合；第二种方法则是直接指定了键值对。

获取集合中的元素可以直接使用键获取，得到的返回值有两个，分别是值和是否存在的标志，如下。

1
2
3
4
5
v, valid := m["apple"]
fmt.Println(v, valid) // -> 10 true

v, valid = m["pear"]
fmt.Println(v, valid) // -> 0, false （未成功取到）

键值对可以直接增加、修改或是使用 delete 删除，也可以使用 len() 获取长度，示例如下。

1
2
3
4
5
6
7
8
var m map[string]int
m["apple"] = 8 // 增加
m["banana"] = 2 // 增加
m["pineapple"] = 5 // 增加
m["apple"] = 10 // 修改
fmt.Println(len(m)) // -> 3
delete(m, "banana") // 删除
fmt.Println(len(m)) // -> 2

结构体

自定义类型

Go 中可以自定义类型，相当于创建了一个新的类型，示例如下。

1
type myint int

这里创建的新类型无法和 int 直接进行运算操作，他可以创建自己的方法（涉及到后面的函数），下面是一个示例。

1
2
3
func (m *myint) add(y myint) {
  (*m) += y
}

自定义结构体

自定义结构体也是一种自定义类型，类似于 C，结构体的定义方式的示例如下。

1
2
3
4
5
type Student struct {
  id string // 类型，变量名
  name string
  age int
}

结构体的初始化有几种方式，如下。

1
2
stu := Student{"1", "casey", 0} // 顺序初始化
stu := Student{id: "1", name: "casey", age: 0} // 指定字段初始化

若在结构体中存在 slice、map和channel，则需要使用到 make，示例如下。

1
stu := Student{id: "1", name: "casey", age: 0, m: make([]int, 0, 5)}

不同于 C 的是，访问结构体成员时，结构体变量和结构体指针都使用 . 来访问成员，示例如下。

1
2
3
4
var stu1 Student;
var stu_ptr *Student = &stu1
// ... 赋值等操作
fmt.Println(stu1.id, stu_ptr.id)

若要实现结构体在包外的访问，需要将结构体的首字母大写，使结构体成为可导出的。若要进一步实现结构体成员的可导出，需要将成员名也相应大写。

结构体可以是匿名的，示例如下。

1
2
3
4
5
var t struct {
  name string 
  id  string
}
// t.name = ...

结构体的字段可以是匿名的，但是由于匿名的原因，同种类型只能有一个，访问方式为直接访问类型，示例如下。

1
2
3
4
5
6
type Student struct {
  string
  int
}
s := Student{"casey", 0}
fmt.Println(s.string, s.int) // -> casey 0

条件语句

Go 中的条件语句有两种，分别是 if 和 switch。

if 语句

if 条件语句的使用方式类似于 C，在语法上有细微的不同：判断条件不用添加 ()，else 需要紧跟 }，示例如下。

1
2
3
4
5
6
7
if a >= 50 { // 判断条件无 ()
  fmt.Println("a >= 50")
} else if a >= 20 { // else 需要紧跟 '}'
  fmt.Println("20 <= a < 50")
} else {
  fmt.Println("a < 20")
}

Go 中的 if 语句可以在条件中初始化变量，这种做法可以限制判断条件的作用范围，不污染命名空间。以前面的集合为例，如下。

1
2
3
4
5
if val, ok := m["pear"]; ok {
  m["pear"] = 7
} else {
  m["pear"] = 5
}

这种写法常见于类型断言和集合查找。

switch 语句

switch 条件语句的使用方式也类似于 C，仅在语法上存在细微不同：变量不用添加 ()，自动进行 break 操作，一个 case 可以有多个条件。示例如下。

1
2
3
4
5
6
7
8
9
10
11
var x bool = true
switch x { // 变量无 ()
case true:
  fmt.Println("This is the first true case") // 自动 break 退出
case true, false: // 多个条件
  fmt.Println("This is the second true case")
case true:
  fmt.Println("This is the third true case")
default:
  fmt.Println("This is the default case")
}

在 switch 中可以使用 fallthrough 来强制执行下一个 case，并配合使用 break 实现提前终止，示例如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var x bool = true
switch x {
case true:
  fmt.Println("This is the first true case") // 输出，下一个强制执行
  fallthrough
case true:
  fmt.Println("This is the second true case") // 输出，下一个强制执行
  fallthrough
case true:
  if true {
    break // 提前终止
  }
  fmt.Println("This is the third true case")
  fallthrough
default:
  fmt.Println("This is the default case")
}

循环语句

Go 中使用 for 循环，与 C 类似，下面是一个示例。

1
2
3
for i := 0; i < 10; i++ {
  fmt.Println(i)
}

对 for 循环稍加修改，可以得到 C 中的 while 循环相同的效果，示例如下。

1
2
3
4
5
6
7
8
9
var i int = 0
for i < 10 { // while (i < 10) {...}
  fmt.Println(i)
  i++
}

for { // while (true) {...}
  fmt.Println(i)
}

类似于 C，Go 也有 break 和 continue 语句。另外 Go 也支持 goto 语句，示例如下。

1
2
3
4
5
6
7
8
9
10
  var i int = 0
LOOP: 
  for i < 10 {
    if (i > 5) {
      i++
      goto LOOP
    }
    i++
    fmt.Println(i)
  }

使用 range 进行遍历。for range 循环可以遍历数组（array）、切片（slice）、通道（channel）或集合（map）的元素。字符串作为一种特殊的数组，也可以使用 range 遍历。示例如下。

1
2
3
4
5
6
for i, val := arr { // arr, slice, str
  fmt.Println(i, val)
}
for key, val := m {
  fmt.Println(key, val)
}

这里可以使用 _ 来忽略 i 或是 val，并且注意这里的 val 是个临时变量，对 val 操作并不会反映到原变量中。

杂项

  1. Go 中的 ... 有可变参数展开的作用，其会将变参展开为独立变量传入，示例如下。
    1
    2
    3
    4
    s1 := []int{1, 2, 3}
    s2 := make([]int, 5, 10)
    s2 = append(s2, s1...) // 展开传入
    fmt.Println(s2) // -> [0 0 0 0 0 1 2 3]
  2. 在 Go 中只有 slice 和 chan（通道） 有 cap() 函数，其他类型都只有 len() 函数，len() 返回实际元素个数。
2025-02-22 该篇文章被 Casey 打上标签: Go 归为分类: 学习

上一篇：Go 快速入门（三） 下一篇：Go 快速入门（一）
© 2025 Casey / 📧联系 / ☕支持 / 🔗链接
脚踏实地, 不断追逐 本站由Hexo驱动｜使用Hexo-theme-A4主题