Go语言编程基础 结构体、切片与映射(二)——数组、切片

6 数组

类型[n]T表示拥有n个T类型的值的数组。

表达式

1
2
3
1var a [10]int

2

3

将变量声明为拥有10个整数的数组。

数组的长度为其类型的一部分，因此数组无法改变大小。

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

2

3import "fmt"

4

5func main()  {

6  var a [2]string

7  a[0] = "iiiii"

8  a[1] = "jjjjj"

9  fmt.Println(a[0], a[1])

10  fmt.Println(a)

11  ttt := [3]int {1, 2, 3}

12  fmt.Println(ttt)

13}

14

15

7 切片

每个数组的大小是固定的，但切片为数组元素提供了动态大小的、灵活的视角。

类型[]T表示一个数组类型为T的切片。
切片通过两个下标来定界，一个上界一个下界，二者以冒号分隔：

1
2
3
1a[low: high]

2

3

它会选择一个半开区间，包括第一个元素，但是排除最后一个元素。

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

2

3import "fmt"

4

5func main() {

6   primes := [6]int{2, 3, 5, 7, 11, 13}

7   s := primes[1:4]

8   fmt.Println(s)

9}

10

11

8 切片类似于数组的引用

切片不存储任何数据，只描述了底层数组中的一段。
更改切片中的元素会修改其底层数组中对应的元素。
与其共享底层数组的切片都会观测到这些修改。

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

2

3import "fmt"

4

5func main()  {

6  names := [4]string{

7    "John",

8    "Paul",

9    "George",

10    "Ringo",

11  }

12  fmt.Println(names)

13  a := names[0: 2]

14  b := names[1: 3]

15  fmt.Println(a, b)

16  b[0] = "XXX"

17  fmt.Println(a, b)

18  fmt.Println(names)

19}

20

21

9 切片文法

切片文法类似于没有长度的数组文法。

1
2
3
4
5
6
1# 数组文法

2[3]bool{true, ture, false}

3# 创建一个数组，并以此建立一个切片

4[]bool{true, true, false}

5

6

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

2

3import "fmt"

4

5func main()  {

6  bbb := []bool{false, true, false, true, false}

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

8  sss := []struct{

9    x int

10    y int

11    } {{1, 2}, {3, 4}}

12  fmt.Println(bbb)

13  fmt.Println(iii)

14  fmt.Println(sss)

15}

16

17

学习源：Go指南