Go语言编程基础 结构体、切片与映射(三)——切片、make

10 切片的默认行为

在进行切片时，可以使用切片的默认行为来忽略上下界。
切片下界的默认值为0，上界则是该切片的长度。

对于数组：

1
2
3
1var a [10]int

2

3

以下切片等价：

1
2
3
4
5
6
1a[0, 10]

2a[: 10]

3a[0:]

4a[:]

5

6

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

2

3import "fmt"

4

5func main()  {

6  iii := [4]int{0, 1, 2, 3}

7

8  s1 := iii[:]

9  s2 := iii[0:]

10  s3 := iii[:4]

11  s4 := iii[0:4]

12

13  fmt.Println(s1)

14  fmt.Println(s2)

15  fmt.Println(s3)

16  fmt.Println(s4)

17}

18

19

11 切片的长度与容量

切片拥有长度与容量。
切片的长度就是其所包含的元素个数。
切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数，注意是指数组。
切片s的长度和容量可以通过表达式len(s)与cap(s)来获取。
可以通过重新切片来扩展一个切片的容量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1package main

2

3import "fmt"

4

5func main()  {

6  s := []int{1, 2, 3, 4, 5, 1, 1, 1, 1, 1}

7  printSlice(s)

8

9  s = s[:0]

10  printSlice(s)

11

12  s = s[:4]

13  printSlice(s)

14

15  s = s[:2]

16  printSlice(s)

17  

18}

19

20func printSlice(s []int) {

21  fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)

22}

23

24

12 nil切片

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

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

2

3import "fmt"

4

5func main()  {

6  var s []int

7  fmt.Println(len(s), cap(s))

8  if s == nil {

9    fmt.Println(s)

10  }

11}

12

13

13 用make创建切片

切片可以用内建函数make创建。
make函数会分配一个元素为零值的数组并返回一个引用了它的切片：

1
2
3
1a := make([]int, 5)

2

3

可以向make传入第三个参数用于指定容量

1
2
3
4
5
1b := make([]int, 0, 5)

2b = b[:cap(b)]

3b = b[1:]

4

5

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

2

3import "fmt"

4

5func main()  {

6  s := make([]int, 5)

7  fmt.Println(s, len(s), cap(s))

8  ss := make([]int, 0, 5)

9  fmt.Println(ss, len(ss), cap(ss))

10}

11

12

学习源：Go指南