提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  后端

当前栏目

Go语言容器（container）

Go容器语言 container
2023-09-11 14:14:56 时间

阅读目录

Go语言容器（container）

变量在一定程度上能满足函数及代码要求。

如果编写一些复杂算法、结构和逻辑，就需要更复杂的类型来实现。

这类复杂类型一般情况下具有各种形式的存储和处理数据的功能，将它们称为“容器（container）”。

在很多语言里，容器是以标准库的方式提供，你可以随时查看这些标准库的代码，了解如何创建，删除，维护内存。

详细介绍 数组、切片、映射，以及列表的增加、删除、修改和遍历的使用方法。

Go语言数组详解

数组是一个由固定长度的特定类型元素组成的序列，一个数组可以由零个或多个元素组成。

因为数组的长度是固定的，所以在Go语言中很少直接使用数组。

和数组对应的类型是 Slice（切片），Slice 是可以增长和收缩的动态序列，功能也更灵活，但是想要理解 slice 工作原理的话需要先理解数组。

Go语言数组的声明

数组的声明语法如下：

var 数组变量名 [元素数量] Type

语法说明如下所示：

  • 数组变量名：数组声明及使用时的变量名。
  • 元素数量：数组的元素数量，可以是一个表达式，但最终通过编译期计算的结果必须是整型数值，元素数量不能含有到运行时才能确认大小的数值。
  • Type：可以是任意基本类型，包括数组本身，类型为数组本身时，可以实现多维数组。

数组的每个元素都可以通过索引下标来访问，索引下标的范围是从 0 开始到数组长度减 1 的位置，内置函数 len() 可以返回数组中元素的个数。

package main

import (
	"fmt"
)

func main() {
	// 定义三个整数的数组
	var a [3]int
	fmt.Println(a[0])
	// 打印第一个元素

	fmt.Println(a[len(a)-1])
	// 打印最后一个元素

	// 打印索引和元素
	for i, v := range a {
		fmt.Printf("%d %d\n", i, v)
	}
	// 仅打印元素
	for _, v := range a {
		fmt.Printf("%d\n", v)
	}
}

E:\go_test>go run main.go
0
0
0 0
1 0
2 0
0
0
0

E:\go_test>

默认情况下，数组的每个元素都会被初始化为元素类型对应的零值，对于数字类型来说就是 0，同时也可以使用数组字面值语法，用一组值来初始化数组：

var q [3]int = [3]int{1, 2, 3}
var r [3]int = [3]int{1, 2}
fmt.Println(r[2]) // "0"

在数组的定义中，如果在数组长度的位置出现 “...” 省略号，则表示数组的长度是根据初始化值的个数来计算，因此，上面数组 q 的定义可以简化为：

q := [...]int{1, 2, 3}
fmt.Printf("%T\n", q) // "[3]int"

数组的长度是数组类型的一个组成部分，因此 [3]int 和 [4]int 是两种不同的数组类型，数组的长度必须是常量表达式，因为数组的长度需要在编译阶段确定。

q := [3]int{1, 2, 3}
q = [4]int{1, 2, 3, 4} 
// 编译错误：无法将 [4]int 赋给 [3]int

比较两个数组是否相等

如果两个数组类型相同（包括数组的长度，数组中元素的类型）的情况下，我们可以直接通过较运算符（==和!=）来判断两个数组是否相等，只有当两个数组的所有元素都是相等的时候数组才是相等的，不能比较两个类型不同的数组，否则程序将无法完成编译。

a := [2]int{1, 2}
b := [...]int{1, 2}
c := [2]int{1, 3}
fmt.Println(a == b, a == c, b == c)
// "true false false"

d := [3]int{1, 2}
fmt.Println(a == d)
// 编译错误：无法比较 [2]int == [3]int

遍历数组—访问每一个数组元素

遍历数组也和遍历切片类似，代码如下所示：

var team [3]string
team[0] = "hammer"
team[1] = "soldier"
team[2] = "mum"

for k, v := range team {
    fmt.Println(k, v)
}

0 hammer
1 soldier
2 mum

Go语言多维数组简述

Go语言中允许使用多维数组，因为数组属于值类型，所以多维数组的所有维度都会在创建时自动初始化零值，多维数组尤其适合管理具有父子关系或者与坐标系相关联的数据。

声明多维数组的语法如下所示：

var array_name [size1][size2]...[sizen] array_type

其中，array_name 为数组的名字，array_type 为数组的类型，size1、size2 等等为数组每一维度的长度。

二维数组是最简单的多维数组，二维数组本质上是由多个一维数组组成的。

【示例 1】声明二维数组

// 声明一个二维整型数组，两个维度的长度分别是 4 和 2
var array [4][2]int

// 使用数组字面量来声明并初始化一个二维整型数组
array = [4][2]int{{10, 11}, {20, 21}, {30, 31}, {40, 41}}

// 声明并初始化数组中索引为 1 和 3 的元素
array = [4][2]int{1: {20, 21}, 3: {40, 41}}

// 声明并初始化数组中指定的元素
array = [4][2]int{1: {0: 20}, 3: {1: 41}}

下图展示了上面示例中声明的二维数组在每次声明并初始化后包含的值。

在这里插入图片描述

为了访问单个元素，需要反复组合使用 [ ] 方括号，如下所示。

【示例 2】为二维数组的每个元素赋值

// 声明一个 2×2 的二维整型数组
var array [2][2]int

// 设置每个元素的整型值
array[0][0] = 10
array[0][1] = 20
array[1][0] = 30
array[1][1] = 40

只要类型一致，就可以将多维数组互相赋值，如下所示，多维数组的类型包括每一维度的长度以及存储在元素中数据的类型。

【示例 3】同样类型的多维数组赋值

// 声明两个二维整型数组
var array1 [2][2]int
var array2 [2][2]int
// 为array2的每个元素赋值
array2[0][0] = 10
array2[0][1] = 20
array2[1][0] = 30
array2[1][1] = 40
// 将 array2 的值复制给 array1
array1 = array2

fmt.Println(array1)

E:\go_test>go run main.go
[[10 20] [30 40]]

因为数组中每个元素都是一个值，所以可以独立复制某个维度，如下所示。

【示例 4】使用索引为多维数组赋值

// 将 array1 的索引为 1 的维度复制到一个同类型的新数组里
var array3 [2]int = array1[1]
// 将数组中指定的整型值复制到新的整型变量里
var value int = array1[1][0]

Go语言切片详解

切片（slice）是对数组的一个连续片段的引用，所以切片是一个引用类型（因此更类似于 C/C++ 中的数组类型，或者 Python 中的 list 类型），这个片段可以是整个数组，也可以是由起始和终止索引标识的一些项的子集，需要注意的是，终止索引标识的项不包括在切片内。

Go语言中切片的内部结构包含地址、大小和容量，切片一般用于快速地操作一块数据集合，如果将数据集合比作切糕的话，切片就是你要的“那一块”，切的过程包含从哪里开始（切片的起始位置）及切多大（切片的大小），容量可以理解为装切片的口袋大小，如下图所示。

在这里插入图片描述

从数组或切片生成新的切片

切片默认指向一段连续内存区域，可以是数组，也可以是切片本身。

从连续内存区域生成切片是常见的操作，格式如下：

slice [开始位置 : 结束位置]

语法说明如下：

  • slice：表示目标切片对象；
  • 开始位置：对应目标切片对象的索引；
  • 结束位置：对应目标切片的结束索引。

从数组生成切片，代码如下：

var a  = [3]int{1, 2, 3}
fmt.Println(a, a[1:2])

其中 a 是一个拥有 3 个整型元素的数组，被初始化为数值 1 到 3，使用 a[1:2] 可以生成一个新的切片，代码运行结果如下：

[1 2 3]  [2]

其中 [2] 就是 a[1:2] 切片操作的结果。

从数组或切片生成新的切片拥有如下特性：

  • 取出的元素数量为： 结束位置 - 开始位置；
  • 取出元素不包含结束位置对应的索引，切片最后一个元素使用 slice[len(slice)] 获取；
  • 当缺省开始位置时，表示从连续区域开头到结束位置；
  • 当缺省结束位置时，表示从开始位置到整个连续区域末尾；
  • 两者同时缺省时，与切片本身等效；
  • 两者同时为 0 时，等效于空切片，一般用于切片复位。

根据索引位置取切片 slice 元素值时，取值范围是（0～len(slice)-1），超界会报运行时错误，生成切片时，结束位置可以填写 len(slice) 但不会报错。

下面通过实例来熟悉切片的特性。

1) 从指定范围中生成切片

切片和数组密不可分，如果将数组理解为一栋办公楼，那么切片就是把不同的连续楼层出租给使用者，出租的过程需要选择开始楼层和结束楼层，这个过程就会生成切片，示例代码如下：

var highRiseBuilding [30]int

for i := 0; i < 30; i++ {
	highRiseBuilding[i] = i + 1
}

// 区间
fmt.Println(highRiseBuilding[10:15])
// 中间到尾部的所有元素
fmt.Println(highRiseBuilding[20:])
// 开头到中间指定位置的所有元素
fmt.Println(highRiseBuilding[:2])

E:\go_test>go run main.go
[11 12 13 14 15]
[21 22 23 24 25 26 27 28 29 30]
[1 2]

E:\go_test>

代码中构建了一个 30 层的高层建筑，数组的元素值从 1 到 30，分别代表不同的独立楼层，输出的结果是不同的租售方案。

切片有点像C语言里的指针，指针可以做运算，但代价是内存操作越界，切片在指针的基础上增加了大小，约束了切片对应的内存区域，切片使用中无法对切片内部的地址和大小进行手动调整，因此切片比指针更安全、强大。

2) 表示原有的切片

生成切片的格式中，当开始和结束位置都被忽略时，生成的切片将表示和原切片一致的切片，并且生成的切片与原切片在数据内容上也是一致的，代码如下：

a := []int{1, 2, 3}
fmt.Println(a[:]) // [1 2 3]

a 是一个拥有 3 个元素的切片，将 a 切片使用 a[:] 进行操作后，得到的切片与 a 切片一致。

3) 重置切片，清空拥有的元素

把切片的开始和结束位置都设为 0 时，生成的切片将变空，代码如下：

a := []int{1, 2, 3}
fmt.Println(a[0:0]) // []

直接声明新的切片

除了可以从原有的数组或者切片中生成切片外，也可以声明一个新的切片，每一种类型都可以拥有其切片类型，表示多个相同类型元素的连续集合，因此切片类型也可以被声明，切片类型声明格式如下：

var name []Type

其中 name 表示切片的变量名，Type 表示切片对应的元素类型。

下面代码展示了切片声明的使用过程：

// 声明字符串切片
var strList []string

// 声明整型切片
var numList []int

// 声明一个空切片
var numListEmpty = []int{}

// 输出3个切片
fmt.Println(strList, numList, numListEmpty)

E:\go_test>go run main.go
[] [] []

E:\go_test>

// 输出3个切片大小
fmt.Println(len(strList), len(numList), len(numListEmpty))

E:\go_test>go run main.go
0 0 0

E:\go_test>

// 切片判定空的结果
fmt.Println(strList == nil)
fmt.Println(numList == nil)
fmt.Println(numListEmpty == nil)

E:\go_test>go run main.go
true
true
false

E:\go_test>

切片是动态结构，只能与 nil 判定相等，不能互相判定相等。声明新的切片后，可以使用 append() 函数向切片中添加元素。

使用 make() 函数构造切片

如果需要动态地创建一个切片，可以使用 make() 内建函数，格式如下：

make( [] Type, size, cap )

其中 Type 是指切片的元素类型，size 指的是为这个类型分配多少个元素，cap 为预分配的元素数量，这个值设定后不影响 size，只是能提前分配空间，降低多次分配空间造成的性能问题。

示例如下：

a := make([]int, 2)
b := make([]int, 2, 10)
fmt.Println(a, b)
fmt.Println(len(a), len(b))

E:\go_test>go run main.go
[0 0] [0 0]
2 2

E:\go_test>

其中 a 和 b 均是预分配 2 个元素的切片，只是 b 的内部存储空间已经分配了 10 个，但实际使用了 2 个元素。

容量不会影响当前的元素个数，因此 a 和 b 取 len 都是 2。

温馨提示

使用 make() 函数生成的切片一定发生了内存分配操作，但给定开始与结束位置（包括切片复位）的切片只是将新的切片结构指向已经分配好的内存区域，设定开始与结束位置，不会发生内存分配操作。

Go语言 append() 为切片添加元素

Go语言的内建函数 append() 可以为切片动态添加元素，代码如下所示：

var a []int

// 追加1个元素
a = append(a, 1) 

// 追加多个元素, 手写解包方式
a = append(a, 1, 2, 3) 

// 追加一个切片, 切片需要解包
a = append(a, []int{1,2,3}...)

不过需要注意的是，在使用 append() 函数为切片动态添加元素时，如果空间不足以容纳足够多的元素，切片就会进行“扩容”，此时新切片的长度会发生改变。

切片在扩容时，容量的扩展规律是按容量的 2 倍数进行扩充，例如 1、2、4、8、16……，代码如下：

package main

import "fmt"

func main() {
	var numbers []int
	for i := 0; i < 10; i++ {
		numbers = append(numbers, i)
		fmt.Printf("len: %d  cap: %d pointer: %p\n",
			len(numbers), cap(numbers), numbers)
	}
}

E:\go_test>go run main.go
len: 1  cap: 1 pointer: 0xc00000e0b8
len: 2  cap: 2 pointer: 0xc00000e100
len: 3  cap: 4 pointer: 0xc0000161a0
len: 4  cap: 4 pointer: 0xc0000161a0
len: 5  cap: 8 pointer: 0xc0000143c0
len: 6  cap: 8 pointer: 0xc0000143c0
len: 7  cap: 8 pointer: 0xc0000143c0
len: 8  cap: 8 pointer: 0xc0000143c0
len: 9  cap: 16 pointer: 0xc00010a080
len: 10  cap: 16 pointer: 0xc00010a080

E:\go_test>

通过查看代码输出，可以发现一个有意思的规律：
切片长度 len 并不等于切片的容量 cap。

往一个切片中不断添加元素的过程，类似于公司搬家，公司发展初期，资金紧张，人员很少，所以只需要很小的房间即可容纳所有的员工，随着业务的拓展和收入的增加就需要扩充工位，但是办公地的大小是固定的，无法改变，因此公司只能选择搬家，每次搬家就需要将所有的人员转移到新的办公点。

  • 员工和工位就是切片中的元素。
  • 办公地就是分配好的内存。
  • 搬家就是重新分配内存。
  • 无论搬多少次家，公司名称始终不会变，代表外部使用切片的变量名不会修改。
  • 由于搬家后地址发生变化，因此内存“地址”也会有修改。

除了在切片的尾部追加，我们还可以在切片的开头添加元素：

import "fmt"

func main() {
	var a = []int{1, 2, 3}

	// 在开头添加1个元素
	a = append([]int{0}, a...)
	fmt.Println(a)

	// 在开头添加1个切片
	a = append([]int{-3, -2, -1}, a...)
	fmt.Println(a)
}

E:\go_test>go run main.go
[0 1 2 3]
[-3 -2 -1 0 1 2 3]

E:\go_test>

在切片开头添加元素一般都会导致内存的重新分配，而且会导致已有元素全部被复制 1 次，因此，从切片的开头添加元素的性能要比从尾部追加元素的性能差很多。

因为 append 函数返回新切片的特性，所以切片也支持链式操作，我们可以将多个 append 操作组合起来，实现在切片中间插入元素：

var a []int
// 在第i个位置插入x
a = append(a[:i], append([]int{x}, a[i:]...)...)
// 在第i个位置插入切片
a = append(a[:i], append([]int{1, 2, 3}, a[i:]...)...)

每个添加操作中的第二个 append 调用都会创建一个临时切片，并将 a[i:] 的内容复制到新创建的切片中，然后将临时创建的切片再追加到 a[:i] 中。

Go语言 copy()：切片复制（切片拷贝）

Go语言的内置函数 copy() 可以将一个数组切片复制到另一个数组切片中，如果加入的两个数组切片不一样大，就会按照其中较小的那个数组切片的元素个数进行复制。

copy() 函数的使用格式如下：

copy( destSlice, srcSlice [] T) int

其中 srcSlice 为数据来源切片，destSlice 为复制的目标（也就是将 srcSlice 复制到 destSlice），目标切片必须分配过空间且足够承载复制的元素个数，并且来源和目标的类型必须一致，copy() 函数的返回值表示实际发生复制的元素个数。

下面的代码展示了使用 copy() 函数将一个切片复制到另一个切片的过程：

slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice2, slice1)
// 只会复制slice1的前3个元素到slice2中

copy(slice1, slice2)
// 只会复制slice2的3个元素到slice1的前3个位置

虽然通过循环复制切片元素更直接，不过内置的 copy() 函数使用起来更加方便，copy() 函数的第一个参数是要复制的目标 slice，第二个参数是源 slice，两个 slice 可以共享同一个底层数组，甚至有重叠也没有问题。

【示例】通过代码演示对切片的引用和复制操作后对切片元素的影响。

package main

import (
	"fmt"
)

func main() {
	// 设置元素数量为1000
	const elementCount = 1000
	// 预分配足够多的元素切片
	srcData := make([]int, elementCount)
	// 将切片赋值
	for i := 0; i < elementCount; i++ {
		srcData[i] = i
	}
	// 引用切片数据
	refData := srcData

	// 预分配足够多的元素切片
	copyData := make([]int, elementCount)
	// 将数据复制到新的切片空间中
	copy(copyData, srcData)

	// 修改原始数据的第一个元素
	srcData[0] = 999
	// 打印引用切片的第一个元素
	fmt.Println(refData[0])
	// os.Exit(1) 999

	// 打印复制切片的第一个和最后一个元素
	fmt.Println(copyData[0], copyData[elementCount-1])
	// os.Exit(1) 0 999

	// 复制原始数据从4到6(不包含)
	copy(copyData, srcData[4:6])
	for i := 0; i < 5; i++ {
		fmt.Printf("%d ", copyData[i])
		// 4 5 2 3 4
	}
}

Go语言从切片中删除元素

Go语言并没有对删除切片元素提供专用的语法或者接口，需要使用切片本身的特性来删除元素，根据要删除元素的位置有三种情况，分别是从开头位置删除、从中间位置删除和从尾部删除，其中删除切片尾部的元素速度最快。

从开头位置删除

删除开头的元素可以直接移动数据指针：

a = []int{1, 2, 3}
a = a[1:] // 删除开头1个元素
a = a[N:] // 删除开头N个元素

也可以不移动数据指针，但是将后面的数据向开头移动，可以用 append 原地完成。

（所谓原地完成是指在原有的切片数据对应的内存区间内完成，不会导致内存空间结构的变化）：

a = []int{1, 2, 3}
a = append(a[:0], a[1:]...) // 删除开头1个元素
a = append(a[:0], a[N:]...) // 删除开头N个元素

还可以用 copy() 函数来删除开头的元素：

a = []int{1, 2, 3}
a = a[:copy(a, a[1:])] // 删除开头1个元素
a = a[:copy(a, a[N:])] // 删除开头N个元素

从中间位置删除

对于删除中间的元素，需要对剩余的元素进行一次整体挪动，同样可以用 append 或 copy 原地完成：

a = []int{1, 2, 3, ...}
a = append(a[:i], a[i+1:]...) // 删除中间1个元素
a = append(a[:i], a[i+N:]...) // 删除中间N个元素
a = a[:i+copy(a[i:], a[i+1:])] // 删除中间1个元素
a = a[:i+copy(a[i:], a[i+N:])] // 删除中间N个元素

从尾部删除

a = []int{1, 2, 3}
a = a[:len(a)-1] // 删除尾部1个元素
a = a[:len(a)-N] // 删除尾部N个元素

删除开头的元素和删除尾部的元素都可以认为是删除中间元素操作的特殊情况，下面来看一个示例。

【示例】删除切片指定位置的元素。

package main

import "fmt"

func main() {
	seq := []string{"a", "b", "c", "d", "e"}
	
	// 指定删除位置
	index := 2
	
	// 查看删除位置之前的元素和之后的元素
	fmt.Println(seq[:index], seq[index+1:])
	
	// 将删除点前后的元素连接起来
	seq = append(seq[:index], seq[index+1:]...)
	fmt.Println(seq)
}

E:\go_test>go run main.go
[a b] [d e]
[a b d e]

E:\go_test>

在这里插入图片描述
Go语言中删除切片元素的本质是，以被删除元素为分界点，将前后两个部分的内存重新连接起来。

提示

连续容器的元素删除无论在任何语言中，都要将删除点前后的元素移动到新的位置，随着元素的增加，这个过程将会变得极为耗时，因此，当业务需要大量、频繁地从一个切片中删除元素时，如果对性能要求较高的话，就需要考虑更换其他的容器了（如双链表等能快速从删除点删除元素）。

Go语言range关键字：循环迭代切片

通过前面的学习我们了解到切片其实就是多个相同类型元素的连续集合，既然切片是一个集合，那么我们就可以迭代其中的元素，Go语言有个特殊的关键字 range，它可以配合关键字 for 来迭代切片里的每一个元素，如下所示：

// 创建一个整型切片，并赋值
slice := []int{10, 20, 30, 40}

// 迭代每一个元素，并显示其值
for index, value := range slice {
    fmt.Printf("Index: %d Value: %d\n", index, value)
}

index 和 value 分别用来接收 range 关键字返回的切片中每个元素的索引和值，这里的 index 和 value 不是固定的，读者也可以定义成其它的名字。

上面代码的输出结果为：

E:\go_test>go run main.go
Index: 0 Value: 10
Index: 1 Value: 20
Index: 2 Value: 30
Index: 3 Value: 40

E:\go_test>

当迭代切片时，关键字 range 会返回两个值，第一个值是当前迭代到的索引位置，第二个值是该位置对应元素值的一份副本，如下图所示。

在这里插入图片描述
需要强调的是，range 返回的是每个元素的副本，而不是直接返回对该元素的引用，如下所示。

【示例 1】range 提供了每个元素的副本

// 创建一个整型切片，并赋值
slice := []int{10, 20, 30, 40}

// 迭代每个元素，并显示值和地址
for index, value := range slice {
	fmt.Printf("Value: %d Value-Addr: %X ElemAddr: %X\n",
		value, &value, &slice[index])
}

E:\go_test>go run main.go
Value: 10 Value-Addr: C000102058 ElemAddr: C000134020
Value: 20 Value-Addr: C000102058 ElemAddr: C000134028
Value: 30 Value-Addr: C000102058 ElemAddr: C000134030
Value: 40 Value-Addr: C000102058 ElemAddr: C000134038

E:\go_test>

因为迭代返回的变量是一个在迭代过程中根据切片依次赋值的新变量，所以 value 的地址总是相同的，要想获取每个元素的地址，需要使用切片变量和索引值（例如上面代码中的 &slice[index] ）。

如果不需要索引值，也可以使用下划线 _ 来忽略这个值，代码如下所示。

【示例 2】使用空白标识符（下划线）来忽略索引值

// 创建一个整型切片，并赋值
slice := []int{10, 20, 30, 40}

// 迭代每个元素，并显示其值
for _, value := range slice {
    fmt.Printf("Value: %d\n", value)
}

E:\go_test>go run main.go
Value: 10
Value: 20
Value: 30
Value: 40

E:\go_test>

关键字 range 总是会从切片头部开始迭代。

如果想对迭代做更多的控制，则可以使用传统的 for 循环，代码如下所示。

【示例 3】使用传统的 for 循环对切片进行迭代

// 创建一个整型切片，并赋值
slice := []int{10, 20, 30, 40}

// 从第三个元素开始迭代每个元素
for index := 2; index < len(slice); index++ {
    fmt.Printf("Index: %d Value: %d\n", index, slice[index])
}

Index: 2 Value: 30
Index: 3 Value: 40

在前面几节的学习中我们了解了两个特殊的内置函数 len() 和 cap()，可以用于处理数组、切片和通道，对于切片，函数 len() 可以返回切片的长度，函数 cap() 可以返回切片的容量，在上面的示例中，使用到了函数 len() 来控制循环迭代的次数。

当然，range 关键字不仅仅可以用来遍历切片，它还可以用来遍历数组、字符串、map 或者通道等。

Go语言多维切片简述

Go语言中同样允许使用多维切片，声明一个多维数组的语法格式如下：

var sliceName [][]...[]sliceType

其中，sliceName 为切片的名字，sliceType为切片的类型，每个 [ ] 代表着一个维度，切片有几个维度就需要几个 [ ] 。

下面以二维切片为例，声明一个二维切片并赋值，代码如下所示。

//声明一个二维切片
var slice [][]int

//为二维切片赋值
slice = [][]int{{10}, {100, 200}}

E:\go_test>go run main.go
[[10] [100 200]]

E:\go_test>

上面的代码也可以简写为下面的样子。

// 声明一个二维整型切片并赋值
slice := [][]int{{10}, {100, 200}}

E:\go_test>go run main.go
[[10] [100 200]]

E:\go_test>

上面的代码中展示了一个包含两个元素的外层切片，同时每个元素包又含一个内层的整型切片，切片 slice 的值如下图所示。

在这里插入图片描述
通过上图可以看到外层的切片包括两个元素，每个元素都是一个切片，第一个元素中的切片使用单个整数 10 来初始化，第二个元素中的切片包括两个整数，即 100 和 200。

这种组合可以让用户创建非常复杂且强大的数据结构，前面介绍过的关于内置函数 append() 的规则也可以应用到组合后的切片上，如下所示。

【示例】组合切片的切片

// 声明一个二维整型切片并赋值
slice := [][]int{{10}, {100, 200}}

// 为第一个切片追加值为 20 的元素
slice[0] = append(slice[0], 20)

E:\go_test>go run main.go
[[10 20] [100 200]]

E:\go_test>

Go语言里使用 append() 函数处理追加的方式很简明，先增长切片，再将新的整型切片赋值给外层切片的第一个元素，当上面代码中的操作完成后，再将切片复制到外层切片的索引为 0 的元素，如下图所示。

在这里插入图片描述
图：append 操作之后外层切片索引为 0 的元素的布局

即便是这么简单的多维切片，操作时也会涉及众多的布局和值，在函数间这样传递数据结构会很复杂，不过切片本身结构很简单，可以用很小的成本在函数间传递。

Go语言map（Go语言映射）

Go语言中 map 是一种特殊的数据结构，一种元素对（pair）的无序集合，pair 对应一个 key（索引）和一个 value（值），所以这个结构也称为关联数组或字典，这是一种能够快速寻找值的理想结构，给定 key，就可以迅速找到对应的 value。

map 概念

map 是引用类型，可以使用如下方式声明：

var mapname map[keytype] valuetype

其中：

  • mapname 为 map 的变量名。
  • keytype 为键类型。
  • valuetype 是键对应的值类型。

提示：[keytype] 和 valuetype 之间允许有空格。

在声明的时候不需要知道 map 的长度，因为 map 是可以动态增长的，未初始化的 map 的值是 nil，使用函数 len() 可以获取 map 中 pair 的数目。

【示例】

package main

import "fmt"

func main() {
	var mapLit map[string]int
	//var mapCreated map[string]float32

	var mapAssigned map[string]int

	mapLit = map[string]int{"one": 1, "two": 2}

	mapCreated := make(map[string]float32)

	mapAssigned = mapLit

	mapCreated["key1"] = 4.5
	mapCreated["key2"] = 3.14159
	mapAssigned["two"] = 3

	fmt.Printf("Map literal at \"one\" is: %d\n", mapLit["one"])
	fmt.Printf("Map created at \"key2\" is: %f\n", mapCreated["key2"])
	fmt.Printf("Map assigned at \"two\" is: %d\n", mapLit["two"])
	fmt.Printf("Map literal at \"ten\" is: %d\n", mapLit["ten"])
}

E:\go_test>go run main.go
Map literal at "one" is: 1
Map created at "key2" is: 3.141590
Map assigned at "two" is: 3
Map literal at "ten" is: 0

E:\go_test>

示例中 mapLit 演示了使用 {key1: value1, key2: value2} 的格式来初始化 map ，就像数组和结构体一样。

上面代码中的 mapCreated 的创建方式
mapCreated := make(map[string]float)
等价于
mapCreated := map[string]float{} 。

mapAssigned 是 mapList 的引用，对 mapAssigned 的修改也会影响到 mapLit 的值。

注意：
可以使用 make()，但不能使用 new() 来构造 map，如果错误的使用 new() 分配了一个引用对象，会获得一个空引用的指针，相当于声明了一个未初始化的变量并且取了它的地址：

mapCreated := new(map[string]float)

接下来当我们调用 mapCreated["key1"] = 4.5 的时候，编译器会报错：

invalid operation: mapCreated["key1"] (index of type *map[string]float).

map 容量

和数组不同，map 可以根据新增的 key-value 动态的伸缩，因此它不存在固定长度或者最大限制，但是也可以选择标明 map 的初始容量 capacity，格式如下：

make(map[keytype]valuetype, cap)

例如：

map2 := make(map[string]float, 100)

当 map 增长到容量上限的时候，如果再增加新的 key-value，map 的大小会自动加 1，所以出于性能的考虑，对于大的 map 或者会快速扩张的 map，即使只是大概知道容量，也最好先标明。

这里有一个 map 的具体例子，即将音阶和对应的音频映射起来：

package main

import "fmt"

func main() {
	noteFrequency := map[string]float32{
		"C0": 16.35, "D0": 18.35, "E0": 20.60, "F0": 21.83,
		"G0": 24.50, "A0": 27.50, "B0": 30.87, "A4": 440}

	fmt.Println(noteFrequency)
}

E:\go_test>go run main.go
map[A0:27.5 A4:440 B0:30.87 C0:16.35 D0:18.35 E0:20.6 F0:21.83 G0:24.5]

E:\go_test>

用切片作为 map 的值

既然一个 key 只能对应一个 value，而 value 又是一个原始类型，那么如果一个 key 要对应多个值怎么办？

例如，当我们要处理 unix 机器上的所有进程，以父进程（pid 为整形）作为 key，所有的子进程（以所有子进程的 pid 组成的切片）作为 value。

通过将 value 定义为 []int 类型或者其他类型的切片，就可以优雅的解决这个问题，示例代码如下所示：

mp1 := make(map[int][]int)
mp2 := make(map[int]*[]int)

Go语言遍历map（访问map中的每一个键值对）

map 的遍历过程使用 for range 循环完成，代码如下：

scene := make(map[string]int)

scene["route"] = 66
scene["brazil"] = 4
scene["china"] = 960
for k, v := range scene {
    fmt.Println(k, v)
}

E:\go_test>go run main.go
route 66
brazil 4
china 960

E:\go_test>

遍历对于Go语言的很多对象来说都是差不多的，直接使用 for range 语法即可，遍历时，可以同时获得键和值。

如只遍历值，可以使用下面的形式：

for _, v := range scene {

将不需要的键使用 _ 改为匿名变量形式。

只遍历键时，使用下面的形式：

for k := range scene {

无须将值改为匿名变量形式，忽略值即可。

注意：遍历输出元素的顺序与填充顺序无关，不能期望 map 在遍历时返回某种期望顺序的结果。

如果需要特定顺序的遍历结果，正确的做法是先排序，代码如下：

package main

import (
	"fmt"
	"sort"
)

func main() {
	scene := make(map[string]int)

	// 准备map数据
	scene["route"] = 66
	scene["brazil"] = 4
	scene["china"] = 960

	// 声明一个切片保存map数据
	var sceneList []string

	// 将map数据遍历复制到切片中
	for k := range scene {
		sceneList = append(sceneList, k)
	}
	
	// 对切片进行排序
	sort.Strings(sceneList)
	// 输出
	fmt.Println(sceneList)
}

E:\go_test>go run main.go
[brazil china route]

E:\go_test>

sort.Strings 的作用是对传入的字符串切片进行字符串字符的升序排列，排序接口的使用将在后面的章节中介绍。

Go语言map元素的删除和清空

Go语言提供了一个内置函数 delete()，用于删除容器内的元素，下面我们简单介绍一下如何用 delete() 函数删除 map 内的元素。

使用 delete() 函数从 map 中删除键值对

使用 delete() 内建函数从 map 中删除一组键值对，delete() 函数的格式如下：

delete(map, 键)

其中 map 为要删除的 map 实例，键为要删除的 map 中键值对的键。

从 map 中删除一组键值对可以通过下面的代码来完成：

scene := make(map[string]int)

// 准备map数据
scene["route"] = 66
scene["brazil"] = 4
scene["china"] = 960

delete(scene, "brazil")
for k, v := range scene {
    fmt.Println(k, v)
}

route 66
china 960

这个例子中使用 delete() 函数将 brazil 从 scene 这个 map 中删除了。

清空 map 中的所有元素

有意思的是，Go语言中并没有为 map 提供任何清空所有元素的函数、方法，清空 map 的唯一办法就是重新 make 一个新的 map，不用担心垃圾回收的效率，Go语言中的并行垃圾回收效率比写一个清空函数要高效的多。

Go语言map的多键索引—多个数值条件可以同时查询

在大多数的编程语言中，映射容器的键必须以单一值存在。

这种映射方法经常被用在诸如信息检索上，如根据通讯簿的名字进行检索。但随着查询条件越来越复杂，检索也会变得越发困难。

下面例子中涉及通讯簿的结构，结构如下：

// 人员档案
type Profile struct {
    Name    string   // 名字
    Age     int      // 年龄
    Married bool     // 已婚
}

并且准备好了一堆原始数据，需要算法实现构建索引和查询的过程，代码如下：

func main() {

    list := []*Profile{
        {Name: "张三", Age: 30, Married: true},
        {Name: "李四", Age: 21},
        {Name: "王麻子", Age: 21},
    }

    buildIndex(list)

    queryData("张三", 30)
}

需要用算法实现 buildIndex() 构建索引函数及 queryData() 查询数据函数，查询到结果后将数据打印出来。

下面，分别基于传统的基于哈希值的多键索引和利用 map 特性的多键索引进行查询。

基于哈希值的多键索引及查询

传统的数据索引过程是将输入的数据做特征值。

这种特征值有几种常见做法：

  • 将特征使用某种算法转为整数，即哈希值，使用整型值做索引。
  • 将特征转为字符串，使用字符串做索引。

数据都基于特征值构建好索引后，就可以进行查询。

查询时，重复这个过程，将查询条件转为特征值，使用特征值进行查询得到结果。

1) 字符串转哈希值

本例中，查询键（classicQueryKey）的特征值需要将查询键中每一个字段转换为整型，字符串也需要转换为整型值，这里使用一种简单算法将字符串转换为需要的哈希值，代码如下：

func simpleHash(str string) (ret int) {

	// 遍历字符串中的每一个ASCII字符
	for i := 0; i < len(str); i++ {
		// 取出字符
		c := str[i]

		// 将字符的ASCII码相加
		ret += int(c)
	}

	return
}

代码说明如下：

1 simpleHash() 传入需要计算哈希值的字符串。

2 根据字符串的长度，遍历这个字符串的每一个字符，以 ASCII 码为单位。

3 c 变量的类型为 uint8，将其转为 int 类型并累加。

哈希算法有很多，这里只是选用一种大家便于理解的算法。

哈希算法的选用的标准是尽量减少重复键的发生，俗称“哈希冲撞”，即同样两个字符串的哈希值重复率降到最低。

2) 查询键

有了哈希算法函数后，将哈希函数用在查询键结构中。

查询键结构如下：

// 查询键
type classicQueryKey struct {
    Name string  // 要查询的名字
    Age  int     // 要查询的年龄
}

// 计算查询键的哈希值
func (c *classicQueryKey) hash() int {
    // 将名字的Hash和年龄哈希合并
    return simpleHash(c.Name) + c.Age*1000000
}

代码说明如下：

1 声明查询键的结构，查询键包含需要索引和查询的字段。

2 查询键的成员方法哈希，通过调用这个方法获得整个查询键的哈希值。

3 查询键哈希的计算方法：
使用 simpleHash() 函数根据给定的名字字符串获得其哈希值。
同时将年龄乘以 1000000 与名字哈希值相加。

哈希值构建过程如下图所示：
在这里插入图片描述

3) 构建索引

本例需要快速查询，因此需要提前对已有的数据构建索引。

前面已经准备好了数据查询键，使用查询键获得哈希即可对数据进行快速索引，参考下面的代码：

// 创建哈希值到数据的索引关系
var mapper = make(map[int][]*Profile)

// 构建数据索引
func buildIndex(list []*Profile) {

    // 遍历所有的数据
    for _, profile := range list {

        // 构建数据的查询索引
        key := classicQueryKey{profile.Name, profile.Age}

        // 计算数据的哈希值, 取出已经存在的记录
        existValue := mapper[key.hash()]

        // 将当前数据添加到已经存在的记录切片中
        existValue = append(existValue, profile)

        // 将切片重新设置到映射中
        mapper[key.hash()] = existValue
    }
}

代码说明如下：

1 实例化一个 map，键类型为整型，保存哈希值；值类型为 *Profile，为通讯簿的数据格式。

2 构建索引函数入口，传入数据切片。

3 遍历数据切片的所有数据元素。

4 使用查询键（classicQueryKey）来辅助计算哈希值，查询键需要填充两个字段，将数据中的名字和年龄赋值到查询键中进行保存。

5 使用查询键的哈希方法计算查询键的哈希值。通过这个值在 mapper 索引中查找相同哈希值的数据切片集合。因为哈希函数不能保证不同数据的哈希值一定完全不同，因此要考虑在发生哈希值重复时的处理办法。

6 将当前数据添加到可能存在的切片中。

7 将新添加好的数据切片重新赋值到相同哈希的 mapper 中。

具体哈希结构如下图所示：

在这里插入图片描述
这种多键的算法就是哈希算法。

map 的多个元素对应哈希的“桶”。

哈希函数的选择决定桶的映射好坏，如果哈希冲撞很厉害，那么就需要将发生冲撞的相同哈希值的元素使用切片保存起来。

4) 查询逻辑

从已经构建好索引的数据中查询需要的数据流程如下：

  • 给定查询条件（名字、年龄）。
  • 根据查询条件构建查询键。
  • 查询键生成哈希值。
  • 根据哈希值在索引中查找数据集合。
  • 遍历数据集合逐个与条件比对。
  • 获得结果。
func queryData(name string, age int) {

    // 根据给定查询条件构建查询键
    keyToQuery := classicQueryKey{name, age}

    // 计算查询键的哈希值并查询, 获得相同哈希值的所有结果集合
    resultList := mapper[keyToQuery.hash()]

    // 遍历结果集合
    for _, result := range resultList {

        // 与查询结果比对, 确认找到打印结果
        if result.Name == name && result.Age == age {
            fmt.Println(result)
            return
        }
    }

    // 没有查询到时, 打印结果
    fmt.Println("no found")
}

代码说明如下：

1，查询条件（名字、年龄）。

2，根据查询条件构建查询键。

3，使用查询键计算哈希值，使用哈希值查询相同哈希值的所有数据集合。

4，遍历所有相同哈希值的数据集合。

5，将每个数据与查询条件进行比对，如果一致，表示已经找到结果，打印并返回。

6，没有找到记录时，打印 no found。

完整代码

package main

import "fmt"

// 人员档案
type Profile struct {
	Name    string // 名字
	Age     int    // 年龄
	Married bool   // 已婚
}

func main() {

	list := []*Profile{
		{Name: "张三", Age: 30, Married: true},
		{Name: "李四", Age: 21},
		{Name: "王麻子", Age: 21},
	}

	buildIndex(list)

	queryData("张三", 30)
}

func simpleHash(str string) (ret int) {

	// 遍历字符串中的每一个ASCII字符
	for i := 0; i < len(str); i++ {
		// 取出字符
		c := str[i]

		// 将字符的ASCII码相加
		ret += int(c)
	}

	return
}

// 查询键
type classicQueryKey struct {
	Name string // 要查询的名字
	Age  int    // 要查询的年龄
}

// 计算查询键的哈希值
func (c *classicQueryKey) hash() int {
	// 将名字的Hash和年龄哈希合并
	return simpleHash(c.Name) + c.Age*1000000
}

// 创建哈希值到数据的索引关系
var mapper = make(map[int][]*Profile)

// 构建数据索引
func buildIndex(list []*Profile) {

	// 遍历所有的数据
	for _, profile := range list {

		// 构建数据的查询索引
		key := classicQueryKey{profile.Name, profile.Age}

		// 计算数据的哈希值, 取出已经存在的记录
		existValue := mapper[key.hash()]

		// 将当前数据添加到已经存在的记录切片中
		existValue = append(existValue, profile)

		// 将切片重新设置到映射中
		mapper[key.hash()] = existValue
	}
}

func queryData(name string, age int) {

	// 根据给定查询条件构建查询键
	keyToQuery := classicQueryKey{name, age}

	// 计算查询键的哈希值并查询, 获得相同哈希值的所有结果集合
	resultList := mapper[keyToQuery.hash()]

	// 遍历结果集合
	for _, result := range resultList {

		// 与查询结果比对, 确认找到打印结果
		if result.Name == name && result.Age == age {
			fmt.Println(result)
			return
		}
	}

	// 没有查询到时, 打印结果
	fmt.Println("no found")

}


E:\go_test>go run main.go
&{张三 30 true}

E:\go_test>

利用 map 特性的多键索引及查询

使用结构体进行多键索引和查询比传统的写法更为简单，最主要的区别是无须准备哈希函数及相应的字段无须做哈希合并。

看下面的实现流程。

1) 构建索引

// 查询键
type queryKey struct {
    Name string
    Age  int
}

// 创建查询键到数据的映射
var mapper = make(map[queryKey]*Profile)

// 构建查询索引
func buildIndex(list []*Profile) {

    // 遍历所有数据
    for _, profile := range list {

        // 构建查询键
        key := queryKey{
            Name: profile.Name,
            Age:  profile.Age,
        }

        // 保存查询键
        mapper[key] = profile
    }
}

代码说明如下：

1，与基于哈希值的查询键的结构相同。

2，在 map 的键类型上，直接使用了查询键结构体。

注意，这里不使用查询键的指针。同时，结果只有 *Profile 类型，而不是 *Profile 切片，表示查到的结果唯一。

3，类似的，使用遍历到的数据的名字和年龄构建查询键。

4，更简单的，直接将查询键保存对应的数据。

2) 查询逻辑

// 根据条件查询数据
func queryData(name string, age int) {

    // 根据查询条件构建查询键
    key := queryKey{name, age}

    // 根据键值查询数据
    result, ok := mapper[key]

    // 找到数据打印出来
    if ok {
        fmt.Println(result)
    } else {
        fmt.Println("no found")
    }
}

代码说明如下：
1，根据查询条件（名字、年龄）构建查询键。
2，直接使用查询键在 map 中查询结果。
3，找到结果直接打印。
4，没有找到结果打印 no found。

总结

基于哈希值的多键索引查询和利用 map 特性的多键索引查询的代码复杂程度显而易见。

聪明的程序员都会利用 Go语言的特性进行快速的多键索引查询。

其实，利用 map 特性的例子中的 map 类型即便修改为下面的格式，也一样可以获得同样的结果：

var mapper = make(map[interface{}]*Profile)

代码量大大减少的关键是：

Go语言的底层会为 map 的键自动构建哈希值。

能够构建哈希值的类型必须是非动态类型、非指针、函数、闭包。

1 非动态类型：可用数组，不能用切片。
2 非指针：每个指针数值都不同，失去哈希意义。
3 函数、闭包不能作为 map 的键。

完整代码

package main

import "fmt"

// 人员档案
type Profile struct {
	Name    string // 名字
	Age     int    // 年龄
	Married bool   // 已婚
}

// 查询键
type queryKey struct {
	Name string
	Age  int
}

// 创建查询键到数据的映射
var mapper = make(map[queryKey]*Profile)

// 构建查询索引
func buildIndex(list []*Profile) {

	// 遍历所有数据
	for _, profile := range list {

		// 构建查询键
		key := queryKey{
			Name: profile.Name,
			Age:  profile.Age,
		}

		// 保存查询键
		mapper[key] = profile
	}
}

// 根据条件查询数据
func queryData(name string, age int) {

	// 根据查询条件构建查询键
	key := queryKey{name, age}

	// 根据键值查询数据
	result, ok := mapper[key]

	// 找到数据打印出来
	if ok {
		fmt.Println(result)
	} else {
		fmt.Println("no found")
	}
}

func main() {
	list := []*Profile{
		{Name: "张三", Age: 30, Married: true},
		{Name: "李四", Age: 21},
		{Name: "王麻子", Age: 21},
	}

	buildIndex(list)

	queryData("张三", 30)
}

E:\go_test>go run main.go
&{张三 30 true}

E:\go_test>

Go语言sync.Map（在并发环境中使用的map）

Go语言中的 map 在并发情况下，只读是线程安全的，同时读写是线程不安全的。

下面来看下并发情况下读写 map 时会出现的问题，代码如下：

package main

func main() {
	// 创建一个int到int的映射
	m := make(map[int]int)

	// 开启一段并发代码
	go func() {
		// 不停地对map进行写入
		for {
			m[1] = 1
		}
	}()

	// 开启一段并发代码
	go func() {
		// 不停地对map进行读取
		for {
			_ = m[1]
		}
	}()
	
	// 无限循环, 让并发程序在后台执行
	for {
	}
}

运行代码会报错，输出如下：

fatal error: concurrent map read and map write

错误信息显示，并发的 map 读和 map 写，也就是说使用了两个并发函数不断地对 map 进行读和写而发生了竞态问题，map 内部会对这种并发操作进行检查并提前发现。

需要并发读写时，一般的做法是加锁，但这样性能并不高，Go语言在 1.9 版本中提供了一种效率较高的并发安全的 sync.Map，sync.Map 和 map 不同，不是以语言原生形态提供，而是在 sync 包下的特殊结构。

sync.Map 有以下特性：

  • 无须初始化，直接声明即可。
  • sync.Map 不能使用 map 的方式进行取值和设置等操作，而是使用 sync.Map 的方法进行调用，Store 表示存储，Load 表示获取，Delete 表示删除。
  • 使用 Range 配合一个回调函数进行遍历操作，通过回调函数返回内部遍历出来的值，Range 参数中回调函数的返回值在需要继续迭代遍历时，返回 true，终止迭代遍历时，返回 false。

并发安全的 sync.Map 演示代码如下：

package main

import (
	"fmt"
	"sync"
)

func main() {
	var scene sync.Map

	// 将键值对保存到sync.Map
	scene.Store("greece", 97)
	scene.Store("london", 100)
	scene.Store("egypt", 200)

	// 从sync.Map中根据键取值
	fmt.Println(scene.Load("london"))

	// 根据键删除对应的键值对
	scene.Delete("london")

	// 遍历所有sync.Map中的键值对
	scene.Range(func(k, v interface{}) bool {
		fmt.Println("iterate:", k, v)
		return true
	})
}

E:\go_test>go run main.go
100 true
iterate: egypt 200
iterate: greece 97

E:\go_test>

代码说明如下：

1，声明 scene，类型为 sync.Map，注意，sync.Map 不能使用 make 创建。

2，将一系列键值对保存到 sync.Map 中，sync.Map 将键和值以 interface{} 类型进行保存。

3，提供一个 sync.Map 的键给 scene.Load() 方法后将查询到键对应的值返回。

4，sync.Map 的 Delete 可以使用指定的键将对应的键值对删除。

5，Range() 方法可以遍历 sync.Map，遍历需要提供一个匿名函数，参数为 k、v，类型为 interface{}，每次 Range() 在遍历一个元素时，都会调用这个匿名函数把结果返回。

sync.Map 没有提供获取 map 数量的方法，替代方法是在获取 sync.Map 时遍历自行计算数量，sync.Map 为了保证并发安全有一些性能损失，因此在非并发情况下，使用 map 相比使用 sync.Map 会有更好的性能。

Go语言list（列表）

列表是一种非连续的存储容器，由多个节点组成，节点通过一些变量记录彼此之间的关系，列表有多种实现方法，如单链表、双链表等。

列表的原理可以这样理解：

假设 A、B、C 三个人都有电话号码，如果 A 把号码告诉给 B，B 把号码告诉给 C，这个过程就建立了一个单链表结构，如下图所示。

在这里插入图片描述
如果在这个基础上，再从 C 开始将自己的号码告诉给自己所知道号码的主人，这样就形成了双链表结构，如下图所示。

在这里插入图片描述
那么如果需要获得所有人的号码，只需要从 A 或者 C 开始，要求他们将自己的号码发出来，然后再通知下一个人如此循环，这样就构成了一个列表遍历的过程。

如果 B 换号码了，他需要通知 A 和 C，将自己的号码移除，这个过程就是列表元素的删除操作，如下图所示。

在这里插入图片描述
图：从双链表中删除一人的电话号码。

在Go语言中，列表使用 container/list 包来实现，内部的实现原理是双链表，列表能够高效地进行任意位置的元素插入和删除操作。

初始化列表

list 的初始化有两种方法：

  • 使用 New() 函数
  • var 关键字声明，

两种方法的初始化效果都是一致的。

  1. 通过 container/list 包的 New() 函数初始化 list。
变量名 := list.New()
  1. 通过 var 关键字声明初始化 list。
var 变量名 list.List

列表与切片和 map 不同的是，列表并没有具体元素类型的限制，因此，列表的元素可以是任意类型，这既带来了便利，也引来一些问题，例如给列表中放入了一个 interface{} 类型的值，取出值后，如果要将 interface{} 转换为其他类型将会发生宕机。

在列表中插入元素

双链表支持从队列前方或后方插入元素，分别对应的方法是 PushFront 和 PushBack。

提示

这两个方法都会返回一个 *list.Element 结构，如果在以后的使用中需要删除插入的元素，则只能通过 *list.Element 配合 Remove() 方法进行删除，这种方法可以让删除更加效率化，同时也是双链表特性之一。

下面代码展示如何给 list 添加元素：

l := list.New()

l.PushBack("fist")
l.PushFront(67)

代码说明如下：

1，创建一个列表实例。

2，将 fist 字符串插入到列表的尾部，此时列表是空的，插入后只有一个元素。

3，将数值 67 放入列表，此时，列表中已经存在 fist 元素，67 这个元素将被放在 fist 的前面。

列表插入元素的方法如下表所示。

方  法 功  能
InsertAfter(v interface {}, mark * Element) * Element 在 mark 点之后插入元素，mark 点由其他插入函数提供
InsertBefore(v interface {}, mark * Element) *Element 在 mark 点之前插入元素，mark 点由其他插入函数提供
PushBackList(other *List) 添加 other 列表元素到尾部
PushFrontList(other *List) 添加 other 列表元素到头部

从列表中删除元素

列表插入函数的返回值会提供一个 *list.Element 结构，这个结构记录着列表元素的值以及与其他节点之间的关系等信息，从列表中删除元素时，需要用到这个结构进行快速删除。

列表操作元素：

package main

import "container/list"

func main() {

	l := list.New()

	// 尾部添加
	l.PushBack("canon")

	// 头部添加
	l.PushFront(67)

	// 尾部添加后保存元素句柄
	element := l.PushBack("fist")

	// 在fist之后添加high
	l.InsertAfter("high", element)

	// 在fist之前添加noon
	l.InsertBefore("noon", element)
	
	// 使用
	l.Remove(element)
}

代码说明如下：

1，创建列表实例。

2，将字符串 canon 插入到列表的尾部。

3，将数值 67 添加到列表的头部。

4，将字符串 fist 插入到列表的尾部，并将这个元素的内部结构保存到 element 变量中。

5，使用 element 变量，在 element 的位置后面插入 high 字符串。

6，使用 element 变量，在 element 的位置前面插入 noon 字符串。

7，移除 element 变量对应的元素。

下表中展示了每次操作后列表的实际元素情况。
列表元素操作的过程：

列表元素操作的过程
操作内容 列表元素
l.PushBack("canon") canon
l.PushFront(67) 67, canon
element := l.PushBack("fist") 67, canon, fist
l.InsertAfter("high", element) 67, canon, fist, high
l.InsertBefore("noon", element) 67, canon, noon, fist, high
l.Remove(element) 67, canon, noon, high

遍历列表—访问列表的每一个元素

遍历双链表需要配合 Front() 函数获取头元素，遍历时只要元素不为空就可以继续进行，每一次遍历都会调用元素的 Next() 函数。

代码如下所示：

l := list.New()

// 尾部添加
l.PushBack("canon")

// 头部添加
l.PushFront(67)

for i := l.Front(); i != nil; i = i.Next() {
    fmt.Println(i.Value)
}

代码输出如下：

67
canon

代码说明如下：

1，创建一个列表实例。

2，将 canon 放入列表尾部。

3，在队列头部放入 67。

4，使用 for 语句进行遍历，其中 i:=l.Front() 表示初始赋值，只会在一开始执行一次，每次循环会进行一次 i != nil 语句判断，如果返回 false ，表示退出循环，反之则会执行 i = i.Next()。

5，使用遍历返回的 *list.Element 的 Value 成员取得放入列表时的原值。

Go语言nil：空值/零值

在Go语言中， 布尔类型的零值（初始值）为 false，数值类型的零值为 0，字符串类型的零值为空字符串""，而指针、切片、映射、通道、函数和接口的零值则是 nil。

nil 是Go语言中一个预定义好的标识符，有过其他编程语言开发经验的开发者也许会把 nil 看作其他语言中的 null（NULL），其实这并不是完全正确的，因为Go语言中的 nil 和其他语言中的 null 有很多不同点。

nil 标识符是不能比较的

package main
import (
    "fmt"
)
func main() {
    fmt.Println(nil==nil)
}

运行结果如下所示：

PS D:\code> go run .\main.go
# command-line-arguments
.\main.go:8:21: invalid operation: nil == nil (operator == not defined on nil)

nil 不是关键字或保留字

nil 并不是Go语言的关键字或者保留字，也就是说我们可以定义一个名称为 nil 的变量，比如下面这样：

var nil = errors.New("my god")

虽然上面的声明语句可以通过编译，但是并不提倡这么做。

nil 没有默认类型

package main
import (
    "fmt"
)
func main() {
    fmt.Printf("%T", nil)
}

E:\go_test>go run main.go
<nil>
E:\go_test>

不同类型 nil 的指针是一样的

func main() {
	var arr []int
	var num *int
	fmt.Printf("%p\n", arr)
	fmt.Printf("%p", num)
}

E:\go_test>go run main.go
0x0
0x0
E:\go_test>

通过运行结果可以看出 arr 和 num 的指针都是 0x0。

不同类型的 nil 是不能比较的

func main() {
    var m map[int]string
    var ptr *int
    fmt.Printf(m == ptr)
}

E:\go_test>go run main.go
# command-line-arguments
.\main.go:10:18: invalid operation: m == ptr (mismatched types map[int]string and *int)

E:\go_test>

两个相同类型的 nil 值也可能无法比较

在Go语言中 map、slice 和 function 类型的 nil 值不能比较，比较两个无法比较类型的值是非法的，下面的语句无法编译。

func main() {
	var s1 []int
	var s2 []int
	fmt.Printf(s1 == s2)
}

E:\go_test>go run main.go
# command-line-arguments
.\main.go:10:13: invalid operation: s1 == s2 (slice can only be compared to nil)

E:\go_test>

通过上面的错误提示可以看出，能够将上述不可比较类型的空值直接与 nil 标识符进行比较，如下所示：

func main() {
	var s1 []int
	fmt.Println(s1 == nil)
}

PS D:\code> go run .\main.go
true

nil 是 map、slice、pointer、channel、func、interface 的零值

package main

import (
	"fmt"
)

func main() {
	var m map[int]string
	var ptr *int
	var c chan int
	var sl []int
	var f func()
	var i interface{}

	fmt.Printf("%#v\n", m)   // map[int]string(nil)
	fmt.Printf("%#v\n", ptr) // (*int)(nil)
	fmt.Printf("%#v\n", c)   // (chan int)(nil)
	fmt.Printf("%#v\n", sl)  // []int(nil)
	fmt.Printf("%#v\n", f)   // (func())(nil)
	fmt.Printf("%#v\n", i)   // <nil>
}

零值是Go语言中变量在声明之后但是未初始化被赋予的该类型的一个默认值。

不同类型的 nil 值占用的内存大小可能是不一样的

一个类型的所有的值的内存布局都是一样的，nil 也不例外，nil 的大小与同类型中的非 nil 类型的大小是一样的。

但是不同类型的 nil 值的大小可能不同。

package main

import (
	"fmt"
	"unsafe"
)

func main() {
	var p *struct{}
	fmt.Println(unsafe.Sizeof(p)) // 8

	var s []int
	fmt.Println(unsafe.Sizeof(s)) // 24

	var m map[int]bool
	fmt.Println(unsafe.Sizeof(m)) // 8

	var c chan string
	fmt.Println(unsafe.Sizeof(c)) // 8

	var f func()
	fmt.Println(unsafe.Sizeof(f)) // 8

	var i interface{}
	fmt.Println(unsafe.Sizeof(i)) // 16
}

具体的大小取决于编译器和架构，上面打印的结果是在 64 位架构和标准编译器下完成的，对应 32 位的架构的，打印的大小将减半。

Go语言 make 和 new 关键字的区别及实现原理

当我们想要在Go语言中初始化一个结构时，其实会使用到两个完全不同的关键字，也就是 make 和 new，同时出现两个用于初始化的关键字对于初学者来说可能会感到非常困惑，不过它们两者却有着完全不同的作用。

在Go语言中， make 关键字的主要作用是初始化内置的数据结构，也就是我们在前面提到的数组、切片和 Channel，而当我们想要获取指向某个类型的指针时可以使用 new 关键字，只是知道如何使用 new 的人真的比较少，下面我们就来介绍一下 make 和 new 它们的区别以及实现原理。

概述

虽然 make 和 new 都是能够用于初始化数据结构，但是它们两者能够初始化的结构类型却有着较大的不同，make 在Go语言中只能用于初始化语言中的基本类型：

slice := make([]int, 0, 100)
hash := make(map[int]bool, 10)
ch := make(chan int, 5)

这些基本类型都是语言为我们提供的，我们在前面已经介绍过了它们初始化的过程以及原理，但是在这里还是需要提醒大家注意的是，这三者返回了不同类型的数据结构：

  • slice 是一个包含 data、cap 和 len 的结构体；
  • hash 是一个指向 hmap 结构体的指针；
  • ch 是一个指向 hchan 结构体的指针。

而另一个用于初始化数据结构的关键字 new 的作用其实就非常简单了，它只是接收一个类型作为参数然后返回一个指向这个类型的指针：

i := new(int)

var v int
i := &v

上述代码片段中的两种不同初始化方法其实是等价的，它们都会创建一个指向 int 零值的指针。

在这里插入图片描述

  • make 用于创建切片、哈希表和管道等内置数据结构。
  • new 用于分配并创建一个指向对应类型的指针。

总结

Go语言中 make 和 new 关键字的实现原理，make 关键字的主要作用是创建切片、哈希表和 Channel 等内置的数据结构，而 new 的主要作用是为类型申请一片内存空间，并返回指向这片内存的指针。

相关文章