array

数组类型，定义方式如下:

var arr [n]type

• arr: 表示变量名称
• n: 表示数组长度
• type: 表示数据类型

常见的数组操作如下:

func main() {
    var arr [5]string  // 声明了一个string类型的数组
    arr[0] = "a1"      // 数组下标是从0开始的
    arr[1] = "b2"      // 赋值操作
    fmt.Printf("The first element is %s\n", arr[0])  // 获取数据
    fmt.Printf("The second element is %s\n", arr[1])
}

• 数组下标都是从 0 开始

由于长度是数组类型的属性，因此 [3]int 与 [4]int 属于不同的类型，数组也就不能改变长度。

数组之间的赋值是值的赋值，即当把一个数组作为参数传入函数的时候，传入的其实是该数组的副本，而不是它的指针。

func testArray(arr [5]string){ // 数组的长度
    arr[2] = "c3"
    return
}
func main() {
    var arr [5]string  // 声明了一个string类型的数组
    arr[0] = "a1"      // 数组下标是从0开始的
    arr[1] = "b2"      // 赋值操作
    testArray(arr)
    fmt.Printf("The first element is %s\n", arr[0])  // 获取数据
    fmt.Printf("The second element is %s\n", arr[1])
    fmt.Printf("The second element is %s\n", arr[2]) // 输出结果为空
}

数组作为函数传递是按值进行传递，并非指针形式。

数组的其他定义方式：

a := [3]int{1, 2, 3} // 声明了一个长度为3的int数组
b := [10]int{1, 2, 3} // 声明了一个长度为 10 的 int 数组，其中前三个元素初始化为 1、2、3，其它默认为 0
c := [...]int{4, 5, 6} // 可以省略长度而采用 `...` 的方式，Go 会自动根据元素个数来计算长度

// 二维数组定义方式
doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}

slice(切片)

在很多应用场景中，数组并不能满足我们的需求。在初始定义数组时，我们并不知道需要多大的数组，因此我们就需要 “动态数组”。在 Go 里面这种数据结构叫 slice

slice 并不是真正意义上的动态数组，而是一个引用类型。

slice总是指向一个底层 array，slice 的声明也可以像 array 一样，只是不需要长度。

// 和声明 array 一样，只是少了长度
var fslice []int

// 声明一个 slice，并初始化数据，如下所示：
slice := []byte {'a', 'b', 'c', 'd'}

slice 可以从一个数组或一个已经存在的 slice 中再次声明。slice 通过 array[i:j] 来获取，其中 i 是数组的开始位置，j 是结束位置，但不包含 array[j]，它的长度是 j-i。 一个前闭后开区间。

// 声明一个含有 10 个元素元素类型为 byte 的数组
var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}

// 声明两个含有 byte 的 slice
var a, b []byte

// a 指向数组的第 3 个元素开始，并到第五个元素结束，
a = ar[2:5]
// 现在 a 含有的元素: ar[2]、ar[3]和ar[4]

// b 是数组 ar 的另一个 slice
b = ar[3:5]
// b 的元素是：ar[3] 和 ar[4]

slice 和数组在声明时的区别：声明数组时，方括号内写明了 数组的长度 或 使用 ... 自动计算长度，而声明 slice 时，方括号内没有任何字符。

// 声明一个数组
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 声明两个 slice
var aSlice, bSlice []byte
aSlice = array[3: 7]
bSlice = array[3: 5]
fmt.Println(aSlice)  // [100 101 102 103] 字符对应的ASCII码
fmt.Println(bSlice) // [100 101]
aSlice[1] = 'm'
fmt.Println(aSlice)  // [100 109 102 103]
fmt.Println(bSlice) // [100 109]
fmt.Println(array)  // [97 98 99 100 109 102 103 104 105 106]
// 我们可以看到改了 aSlice 中的某个值后，array, aSlice, bSlice 全部都发生了改变

slice 是引用类型，所以当引用改变其中元素的值时，其它的所有引用都会改变该值，例如上面的 aSlice 和 bSlice，如果修改了 aSlice 中元素的值，那么 bSlice 相对应的值也会改变。

从概念上面来说 slice 像一个结构体，这个结构体包含了三个元素：

• 一个指针，指向数组中 slice 指定的开始位置
• 长度，即 slice 的长度
• 最大长度，也就是 slice 开始位置到数组的最后位置的长度

Array_a := [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
Slice_a := Array_a[2:5]

上面代码的存储结构如下图所示

slice 有几个有用的内置函数：

• len 获取 slice 的长度
• cap 获取 slice 的最大容量
• append 向 slice 里面追加一个或者多个元素，然后返回一个和 slice 一样类型的 slice
• copy 函数 copy 从源 slice 的 src 中复制元素到目标 dst，并且返回复制的元素的个数.

append 函数会改变 slice 所引用的数组的内容，从而影响到引用同一数组的其它 slice。

但当 slice 中没有剩余空间（即 (cap-len) == 0 ）时，此时将动态分配新的数组空间。

返回的 slice 数组指针将指向这个空间，而原数组的内容将保持不变； 其它引用此数组的 slice 则不受影响。

例如下面例子:

// 声明一个数组
var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
// 声明两个 slice
var aSlice, bSlice []byte
aSlice = array[3: 7]
bSlice = array[4: 5]

fmt.Printf("aSlice: (%d, %d), bSlice: (%d, %d), array: %d \n", len(aSlice), cap(aSlice), len(bSlice), cap(bSlice), len(array))
// aSlice: (4, 7), bSlice: (1, 6), array: 10 


// 下面是append方法对切片引用的影响
bSlice = append(bSlice, 'x')
fmt.Println(aSlice)  // [100 109 120 103]  因为长度已经超过
fmt.Println(bSlice) // [100 109 120]
fmt.Println(array)  // [97 98 99 100 109 120 103 104 105 106]

• slice 从数组中截取切片的时候，len是区间长度，cap是到数组结尾长度。
• 使用 append 方法向区间中放数据，在没有超出容量 cap 情况下，同样会影响到其他的内容。
• 如果 slice 的长度不够用，会产生一个新的空间，这样就不会影响到数组和其他了。

例如下面的：

slice := array[2:4:7]
fmt.Print("slice:", len(slice), cap(slice)) // slice:2 5

上面这个的容量通过额外的参数进行指定。如上 7-2，即 5。这样这个产生的新的 slice 就没办法访问最后的三个元素。

如果 slice 是这样的形式 array[:i:j]，即第一个参数为空，默认值就是 0。

map

map 也就是 Python 中字典的概念，它的格式为 map[keyType]valueType

我们看下面的代码，map 的读取和设置也类似 slice 一样，通过 key 来操作，只是 slice 的 index 只能是 int 类型，而 map 多了很多类型，可以是 int，可以是 string 及所有完全定义了 == 与 != 操作的类型。

// 声明一个 key 是字符串，值为 int 的字典, 这种方式的声明需要在使用之前使用 make 初始化
var numbers map[string]int
// 另一种 map 的声明方式
numbers := make(map[string]int)
numbers["one"] = 1  // 赋值
numbers["ten"] = 10 // 赋值
numbers["three"] = 3

fmt.Println("第三个数字是: ", numbers["three"]) // 读取数据
// 打印出来如:第三个数字是: 3

这个 map 就像我们平常看到的表格一样，左边列是 key，右边列是值

使用 map 过程中需要注意的几点：

• map 是无序的，每次打印出来的 map 都会不一样，它不能通过 index 获取，而必须通过 key 获取
• map 的长度是不固定的，也就是和 slice 一样，也是一种引用类型
• 内置的 len 函数同样适用于 map，返回 map 拥有的 key 的数量
• map 的值可以很方便的修改，通过 numbers["one"]=11 可以很容易的把 key 为 one 的字典值改为 11

在 Go 中，没有值可以安全地进行并发读写，它不是 thread-safe，在多个 go-routine 存取时，必须使用 mutex lock 机制。

map 的初始化可以通过 key:val 的方式初始化值，同时 map 内置有判断是否存在 key 的方式

通过 delete 删除 map 的元素。

map 也是一种引用类型，如果两个 map 同时指向一个底层，那么一个改变，另一个也相应的改变.

make、new 操作

make 用于内建类型（map、slice 和 channel）的内存分配。new 用于各种类型的内存分配。

官方定义：new是一个分配内存的内置函数，第一个参数是类型，而不是值，返回的值是指向该类型新分配的零值的指针。

内建函数 new 本质上说跟其它语言中的同名函数功能一样：new(T) 分配了零值填充的 T 类型的内存空间，并且返回其地址，即一个 *T 类型的值。用 Go 的术语说，它返回了一个指针，指向新分配的类型 T 的零值。

new 返回指针。

内建函数 make(T, args) 与 new(T) 有着不同的功能，make 只能创建 slice、map 和 channel，并且返回一个有初始值 (非零) 的 T 类型，而不是 *T。

本质来讲，导致这三个类型有所不同的原因是指向数据结构的引用在使用前必须被初始化。

例如，一个 slice，是一个包含指向数据（内部 array）的指针、长度和容量的三项描述符；在这些项目被初始化之前，slice 为 nil。对于 slice、map 和 channel 来说，make 初始化了内部的数据结构，填充适当的值。

make 返回初始化后的（非零）值。

更多的学习可以参考这里的文章: Go语言中make和new有什么区别？