本文是学习 (中文参考 ) 整理的笔记，介绍Go 语言的指针，结构体，数组，切片，映射和闭包的基本概念和使用。

1. 指针

$GOPATH/src/go_note/gotour/advancetype/pointer/pointer.go 源码如下:

/** * go 语言指针 */package mainimport (	"fmt")func main() {	i, j := 42, 36	p := &i	fmt.Println(*p) // 42	*p = 21	fmt.Println(i) // 21	p = &j	*p = *p / 4	fmt.Println(j) // 9}

Go 具有指针。 指针保存了变量的内存地址。类型 *T 是指向 T 类型值的指针，其零值为 nil 。

var p *int

& 操作符会生成一个指向其操作数的指针。

i := 42p = &i

* 操作符表示指针指向的底层值。

fmt.Println(*p) // 通过指针 p 读取 i*p = 21         // 通过指针 p 设置 i

2. 结构体

$GOPATH/src/go_note/gotour/advancetype/struct/struct.go 源码如下:

package mainimport (	"fmt")type Point struct {	X int	Y int}var (	p1  = Point{1, 2}	p2  = Point{X: 1}	p3  = Point{}	pt1 = &Point{1, 2})func main() {	fmt.Println(Point{1, 2})	p := Point{3, 4}	p.X = 4 // 结构体字段使用点号来访问	fmt.Println(p, p.Y)	pt := &p	pt.X = 5 // 使用隐式间接引用，直接写 `pt.X`	(*pt).Y = 6 // 通过 `(*pt).Y` 来访问其字段 `Y`	fmt.Println(p)}

一个结构体（ struct ）就是一个字段的集合，结构体字段使用点号来访问。

2.1 结构体指针

结构体字段可以通过结构体指针来访问。

pt := &ppt.X = 5(*pt).Y = 6

如果我们有一个指向结构体的指针 pt ，那么可以通过 (*pt).X 来访问其字段 X，也可以使用隐式间接引用，直接写 pt.X。

2.2 结构体语法

结构体文法通过直接列出字段的值来新分配一个结构体。

使用 Name: 语法可以仅列出部分字段。（字段名的顺序无关。）

特殊的前缀 & 返回一个指向结构体的指针。

var (	p1  = Point{1, 2}	p2  = Point{X: 1}	p3  = Point{}	pt1 = &Point{1, 2})

3. 数组

$GOPATH/src/go_note/gotour/advancetype/array/array.go 源码如下:

/** * go 语言数组 */package mainimport (	"fmt")func main() {	var a [2]string	a[0] = "hello"	a[1] = "world"	fmt.Println(a, a[0])	list := [10]int{1, 2, 3, 4}	fmt.Println(list)}

类型 [n]T 表示拥有 n 个 T 类型的值的数组。

表达式

var a [10]int // 变量 a 声明为拥有 10 个整数的数组

数组的长度是其类型的一部分，因此数组不能改变大小

4. 切片

$GOPATH/src/go_note/gotour/advancetype/slice/slice.go 源码如下:

/** * go 语言 slice */package mainimport (	"fmt"	"strings")func main() {	primes := [6]int{1, 2, 3, 4, 5, 6}	var s []int = primes[1:4]	fmt.Println(s) // [2 3 4]	names := [4]string{"john", "paul", "george", "ringo"}	fmt.Println(names) // [john paul george ringo]	a := names[0:2]	b := names[1:3]	fmt.Println(a, b) // [john paul] [paul george]	b[0] = "xxx"             // 更改切片的元素会修改其底层数组中对应的元素，并且与它共享底层数组的切片都会观测到这些修改	fmt.Println(a, b, names) // [john xxx] [xxx george] [john xxx george ringo]	// 默认分片上下界	i := []int{1, 2, 3, 4}	fmt.Println(i[0:4]) // [1 2 3 4]	fmt.Println(i[:4])  // [1 2 3 4]	fmt.Println(i[0:])  // [1 2 3 4]	fmt.Println(i[:])   // [1 2 3 4]	// 长度与容量	fmt.Printf("len=%d, cap=%d, %v\n", len(i[:4]), cap(i[:4]), i[:4])    // len=4, cap=4, [1 2 3 4]	fmt.Printf("len=%d, cap=%d, %v\n", len(i[2:4]), cap(i[2:4]), i[2:4]) // len=2, cap=2, [3 4]	// nil 切片	var j []int	fmt.Printf("len=%d, cap=%d, %v\n", len(j), cap(j), j) // len=0, cap=0, []	// make 创建切片	a_m := make([]int, 5)	b_m := make([]int, 0, 5)	fmt.Printf("len=%d, cap=%d, %v\n", len(a_m), cap(a_m), a_m) // len=5, cap=5, [0 0 0 0 0]	fmt.Printf("len=%d, cap=%d, %v\n", len(b_m), cap(b_m), b_m) // len=0, cap=5, []	// 包含切片的切片	board := [][]string{		[]string{"_", "_", "_"},		[]string{"_", "_", "_"},		[]string{"_", "_", "_"},	}	for i := 0; i < len(board); i++ {		fmt.Printf("%s\n", strings.Join(board[i], " "))	}	// 向切片追加元素	var s_p []int	fmt.Printf("len=%d, cap=%d, %v\n", len(s_p), cap(s_p), s_p) // len=0, cap=5, []	s_p = append(s_p, 1)	s_p = append(s_p, 2)	fmt.Printf("len=%d, cap=%d, %v\n", len(s_p), cap(s_p), s_p) // len=0, cap=5, []}

每个数组的大小都是固定的，而切片则提供动态数组，类型 []T 表示一个元素类型为 T 的切片。切片类似不限定长度的数组。

4.1 切片是数组的引用

切片并不存储任何数据，它只是描述了底层数组中的一段。更改切片的元素会修改其底层数组中对应的元素，并且与它共享底层数组的切片都会观测到这些修改。

如下创建一个切片时，会先创建数组，然后构建一个引用了它的切片

[]bool{true, true, false}

4.2 切片的默认行为

在进行切片时，切片有默认上下界。切片下界的默认值为 0 ，上界则是该切片的长度。

对于数组

var a [10]int

来说，以下切片是等价的：

a[0:10]a[:10]a[0:]a[:]

4.3 切片的长度与容量

切片拥有 长度 和 容量

• 长度就是它所包含的元素个数。
• 容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。

切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。

切片的零值是 nil, nil 切片的长度和容量为 0 且没有底层数组。

4.4 make 创建切片

切片可以用内建函数 make 来创建，这也是你创建动态数组的方式。make 函数会分配一个元素为零值的数组并返回一个引用了它的切片：

a := make([]int, 5)  // len(a)=5

要指定它的容量，需向 make 传入第三个参数：

b := make([]int, 0, 5) // len(b)=0, cap(b)=5

4.5 切片的切片

切片可包含任何类型，甚至包括其它的切片

board := [][]string{    []string{"_", "_", "_"},    []string{"_", "_", "_"},    []string{"_", "_", "_"},}

4.6 append 向切片追加元素

为切片追加新的元素是种常用的操作，为此 Go 提供了内建的 append 函数

func append(s []T, vs ...T) []T

append 的第一个参数 s 是一个元素类型为 T 的切片， 其余类型为 T 的值将会追加到该切片的末尾。append 的结果是一个包含原切片所有元素加上新添加元素的切片。当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组。 返回的切片会指向这个新分配的数组。

5. range

$GOPATH/src/go_note/gotour/advancetype/range/range.go 源码如下:

/** * go 语言 range用法 */package mainimport "fmt"var pow = []int{1, 2, 4, 8, 16, 32}func main() {    for i, v := range pow {        fmt.Printf("2**%d = %d\n", i, v)    }    // 2**0 = 1    // 2**1 = 2    // 2**2 = 4    // 2**3 = 8    // 2**4 = 16    // 2**5 = 32    s := make([]int, 5)    for i := range s {        s[i] = 1 << uint(i) // == 2**i    }    for _, v := range s {        fmt.Printf("%d\n", v)    }}

for 循环的 range 形式可遍历切片或映射。

当使用 for 循环遍历切片时，每次迭代都会返回两个值。 第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。

可以将下标或值赋予 _ 来忽略它, 若你只需要索引，去掉 , value 的部分即可。

6. 映射

$GOPATH/src/go_note/gotour/advancetype/map/map.go 源码如下:

/** * go 语言映射 */package mainimport (    "fmt")type Vertex struct {    Lit, Log float64}var m map[string]Vertexvar m1 = map[string]Vertex{ // 定义并初始化一个映射    "Bell Labs": Vertex{        40.123, -74.123,    },    "Google": Vertex{        37.123, -122.123,    },}var m2 = map[string]Vertex{ // 当顶级域名只是一个类型名时，可以在定义语句中省略它    "Bell Labs": {40.123, -74.123},    "Google": {37.123, -74.123},}func main() {    m = make(map[string]Vertex) // make 返回给定类型的映射，并将其初始化备用    m["Bell Labs"] = Vertex{40.123, -74.123}    fmt.Println(m["Bell Labs"], m2)    user := make(map[string]int)    user["Age"] = 42    fmt.Println(user["Age"])    delete(user, "Age")    fmt.Println(user["Age"])    v, ok := user["Age"]    fmt.Println("The Age:", v, "Presen?", ok)}

映射将键映射到值, 映射的零值为 nil, nil 映射既没有键，也不能添加键。make 函数会返回给定类型的映射，并将其初始化备用。

6.1 修改映射

在映射 m 中插入或修改元素：

m[key] = elem

获取元素：

elem = m[key]

删除元素：

delete(m, key)

通过双赋值检测某个键是否存在：

elem, ok = m[key]

若 key 在 m 中， ok 为 true ；否则， ok 为 false

若 key 不在映射中，那么 elem 是该映射元素类型的零值。同样的，当从映射中读取某个不存在的键时，结果是映射的元素类型的零值。

7. 闭包

$GOPATH/src/go_note/gotour/advancetype/closure/closure.go 源码如下:

/** * go 语言闭包 */package mainimport (    "fmt"    "math")func compute(fn func(float64, float64) float64) float64{    return fn(3, 4)}// adder 返回一个闭包, 每个闭包都被绑定在其各自的 sum 变量上。func adder() func (int) int {    sum := 0    return func (x int) int {        sum += x        return sum    }}func main() {    hypot := func (x, y float64) float64 {        return math.Sqrt(x*x + y*y)    }    fmt.Println(hypot(5, 12)) // 13    fmt.Println(compute(hypot)) // 5    fmt.Println(compute(math.Pow)) // 81    pos, neg := adder(), adder()    fmt.Printf("%v\n", pos)    for i := 0; i < 10; i++ {        fmt.Println(i, pos(i), -2*i, neg(-2*i))    }}

函数也是值，它们可以像其它值一样传递，函数值可以用作函数的参数或返回值。

Go 函数可以是一个闭包。闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并赋值其引用的变量的值，也即该函数被“绑定”在了这些变量上。

参考