Golang中的切片

数组是固定长度，可以容纳相同数据类型的元素的集合。当长度固定时，使用还是带来一些限制，比如：有时候申请的长度太大浪费内存，太小又不够用。

鉴于这个原因，我们有了Golang中的切片的概念。

可以把切片理解为，可变长度的数组，其实它底层就是使用数组实现的，增加了自动扩容功能。

切片（Slice）是一个拥有相同类型元素的可变长度的序列。

Golang切片的语法

声明一个切片和声明一个数组类似，只要不添加长度就可以了。

1
var identifier []type

切片是引用类型，可以使用make函数来创建切片：

1
2
3
var slice1 []type = make([]type, len)
也可以简写为
slice1 := make([]type, len)

也可以指定容量，其中capacity为可选参数。

1
make([]T, length, capacity)

这里的len是数组的长度并且也是切片的初始长度。

Golang的切片实例

未初始化切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func basic_slice() {
	var s1 []int
	var s2 []string
	fmt.Printf("s1: %v\n", s1)
	fmt.Printf("s2: %v\n", s2)
}

func main() {
	basic_slice()
}

运行结果

1
2
s1: []
s2: []

make切片,未赋值与赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import "fmt"

func basic_slice2() {
	var s2 = make([]int, 2)
	fmt.Printf("s2: %v\n", s2)
	s2[1] = 1
	fmt.Printf("s2: %v\n", s2)
}

func main() {
	basic_slice2()
}

运行结果

1
2
s2: [0 0]
s2: [0 1]

Golang中的切片的长度和容量

切片拥有自己的长度和容量，可以通过使用内置的len()函数求长度，使用内置的cap（）函数求切片的容量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func len_slice() {
	var s1 = []int{1, 2, 3}
	fmt.Printf("len(s1): %v\n", len(s1))
	fmt.Printf("cap(s1): %v\n", cap(s1))
	fmt.Printf("s1[0]: %v\n", s1[0])
}

func main() {
	len_slice()
}

运行结果

1
2
3
len(s1): 3
cap(s1): 3
s1[0]: 1