【Go事】一眼看穿 Go 的集合和切片

⛳️ Go 集合

在 Go 中与集合相关的关键字是 Map，其表示一种无需的键值对集合，Map 可以通过 Key 检索值，这一点和 Python 中的字典特别像。

集合是无序的，并且使用 hash 表实现。

定义集合

使用 map 关键字定义集合，原型如下：

var map_name map[key_type]value_type
1

参数说明如下：

• map_name：集合变量名；
• key_type：键类型；
• value_type：值类型。

Go 中的 map 可动态扩展，无需按照数组一样声明长度。

接下来进行一个简单的声明和使用，代码如下：

package main

import (
	"fmt"
)

func main() {
	// 创建集合
	var map_var map[string]string

	// 在使用 map 前，需要先 make,其作用是给 map 分配数据空间
	map_var = make(map[string]string)
	map_var["red"] = "红色"
	map_var["green"] = "绿色"
	map_var["blue"] = "蓝色"

	for color := range map_var {
		fmt.Println(color, "中文：", map_var[color])
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

要注意如果创建了集合，但是没有使用 make 函数，就会报错，原因也是未分配内存。

如果希望不使用 map 就可以声明和初始化集合，可以在声明的时候，直接赋值。

package main

import (
	"fmt"
)

func main() {
	// 创建集合
	map_var := map[string]string{
		"red":   "红色",
		"green": "绿色",
		"blue":  "蓝色",
	}

	for color := range map_var {
		fmt.Println(color, "中文：", map_var[color])
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Map 元素删除

直接使用内置的 delete 方法即可。

package main

import (
	"fmt"
)

func main() {
	// 创建集合
	map_var := map[string]string{
		"red":   "红色",
		"green": "绿色",
		"blue":  "蓝色",
	}
	// 删除一个元素
	delete(map_var, "red")
	for color := range map_var {
		fmt.Println(color, "中文：", map_var[color])
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Go 切片

在 Python 中提及切片就是只的取列表的子集，但是在 Go 中是对数组的抽象，在 Go 中切片是一种类型，也叫作动态数组，可以追加扩容元素。

一个切片结构体由三部分构成，Pointer 指向数组的指针，len 切片的长度，cap 切片容量，容量大于等于长度。

我们可以直接声明【未设定大小】的数组定义切片，基础语法格式是：

var identifier []type
1

上述声明默认值是 nil，其中 len=0，cap=0。

使用下述代码可以进行测试。

package main

import "fmt"

func main() {
	var slice_var []int

	sliceFormat(slice_var)

	if slice_var == nil {
		fmt.Printf("空切片")
	}
}

func sliceFormat(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

声明一个拥有初始长度或特定容量的切片，使用 make 函数完成。

var slice_var []type = make([]type, length, capacity)
1

其中第一个参数是类型，第二个是切片的长度，在这种情况下，切片的容量也是 5，可以测试下述代码。

capacity 可以缺省，即下述代码：

package main

import "fmt"

func main() {
	num_slice := make([]int, 5)
	printSlice(num_slice)
}

func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}
1
2
3
4
5
6
7
8
9
10
11
12

运行代码，得到下述输出：

len=5 cap=5 slice=[0 0 0 0 0]
1

可以测试切换不同类型，例如 bool，切片被系统自动初始化为 false。

len=5 cap=5 slice=[false false false false false]
1

声明切片的同时进行初始化

package main

import "fmt"

func main() {
	slice_var := []int{1, 2, 3}
	printSlice(slice_var)
}

func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}
1
2
3
4
5
6
7
8
9
10
11
12

上述代码直接完成切片声明和初始化操作，表示切片使用 [] 符号，{1,2,3} 表示初始化数据。

可以在已经声明好的切片中进行元素添加，需要使用内建函数 append 添加元素。

package main

import "fmt"

func main() {
	num_slice := make([]int, 5, 10)
	num_slice = append(num_slice, 6)
	printSlice(num_slice)
}

func printSlice(x []int) {
	fmt.Printf("len=%d cap=%d slice=%v\n", len(x), cap(x), x)
}
1
2
3
4
5
6
7
8
9
10
11
12
13

多次验证之后，会发现当长度大于 2 时，切片的容量会自动扩容为原来的 2 倍。

# 当 len =10 ,cap =10 时，输出结果
len=10 cap=10 slice=[0 0 0 0 0 6 7 8 9 10]
# 扩容之后的结果
len=11 cap=20 slice=[0 0 0 0 0 6 7 8 9 10 11]
1
2
3
4

📢📢📢📢📢📢
💗 你正在阅读 【梦想橡皮擦】 的博客
👍 阅读完毕，可以点点小手赞一下
🌻 发现错误，直接评论区中指正吧
📆 橡皮擦的第 701 篇原创博客

从订购之日起，案例5年内保证更新

• ⭐️ Python 爬虫 120，点击订购 ⭐️
• ⭐️ 爬虫100例教程，点击订购 ⭐️