Golang学习笔记—

Golang学习笔记——Slice

切片和数组很类似，甚至你可以理解成数组的子集。但是`切片有一个数组所没有的特点，那就是切片的长度是可变的`。

严格地讲，切片有`容量(capacity)`和`长度(length)`两个属性。

首先我们来看一下切片的定义。切片有两种定义方式，一种是先声明一个变量是切片，然后使用内置函数make去初始化这个切片。另外一种是通过取数组切片来赋值。

 1 package main
 2 
 3     import (
 4         "fmt"
 5     )
 6 
 7     func main() {
 8         var x = make([]float64, 5)
 9         fmt.Println("Capcity:", cap(x), "Length:", len(x))
10         var y = make([]float64, 5, 10)
11         fmt.Println("Capcity:", cap(y), "Length:", len(y))
12 
13         for i := 0; i < len(x); i++ {
14             x[i] = float64(i)
15         }
16         fmt.Println(x)
17 
18         for i := 0; i < len(y); i++ {
19             y[i] = float64(i)
20         }
21         fmt.Println(y)
22     }

输出结果为

Capcity: 5 Length: 5
Capcity: 10 Length: 5
[0 1 2 3 4]
[0 1 2 3 4]

上面我们首先用make函数定义切片x，这个时候x的容量是5，长度也是5。然后使用make函数定义了切片y，这个时候y的容量是10，长度是5。然后我们再分别为切片x和y的元素赋值，最后输出。

所以使用make函数定义切片的时候，有`两种方式`，一种`只指定长度，这个时候切片的长度和容量是相同的`。另外一种是`同时指定切片长度和容量`。虽然切片的容量可以大于长度，但是`赋值的时候要注意最大的索引仍然是len(x)－1`。否则会报索引超出边界错误。

另外一种是通过数组切片赋值，采用`[low_index:high_index]`的方式获取数值切片，其中切片元素`包括low_index的元素`，但是`不包括high_index的元素`。

 1 package main
 2 
 3     import (
 4         "fmt"
 5     )
 6 
 7     func main() {
 8         var arr1 = [5]int{1, 2, 3, 4, 5}
 9         var s1 = arr1[2:3]
10         var s2 = arr1[:3]
11         var s3 = arr1[2:]
12         var s4 = arr1[:]
13         fmt.Println(s1)
14         fmt.Println(s2)
15         fmt.Println(s3)
16         fmt.Println(s4)
17     }

输出结果为

[3]
[1 2 3]
[3 4 5]
[1 2 3 4 5]

在上面的例子中，我们还省略了low_index或high_index。如果省略了low_index，那么等价于从索引0开始；如果省略了high_index，则默认high_index等于len(arr1)，即切片长度。

这里为了体现切片的长度可以变化，我们看一下下面的例子：

 1 package main
 2 
 3     import (
 4         "fmt"
 5     )
 6 
 7     func main() {
 8         var arr1 = make([]int, 5, 10)
 9         for i := 0; i < len(arr1); i++ {
10             arr1[i] = i
11         }
12         fmt.Println(arr1)
13 
14         arr1 = append(arr1, 5, 6, 7, 8)
15         fmt.Println("Capacity:", cap(arr1), "Length:", len(arr1))
16         fmt.Println(arr1)
17     }

输出结果为

[0 1 2 3 4]
Capacity: 10 Length: 9
[0 1 2 3 4 5 6 7 8]

这里我们初始化arr1为容量10，长度为5的切片，然后为前面的5个元素赋值。然后输出结果。然后我们再使用Go内置方法append来为arr1追加四个元素，这个时候再看一下arr1的容量和长度以及切片元素，我们发现切片的长度确实变了。

另外我们再用`append`方法给arr1多追加几个元素，试图超过arr1原来定义的容量大小。

 1 package main
 2 
 3     import (
 4         "fmt"
 5     )
 6 
 7     func main() {
 8         var arr1 = make([]int, 5, 10)
 9         for i := 0; i < len(arr1); i++ {
10             arr1[i] = i
11         }
12 
13         arr1 = append(arr1, 5, 6, 7, 8, 9, 10)
14         fmt.Println("Capacity:", cap(arr1), "Length:", len(arr1))
15         fmt.Println(arr1)
16     }

输出结果为

Capacity: 20 Length: 11
[0 1 2 3 4 5 6 7 8 9 10]

我们发现arr1的长度变为11，因为元素个数现在为11个。另外我们发现arr1的容量也变了，变为原来的两倍。这是因为`Go在默认的情况下，如果追加的元素超过了容量大小，Go会自动地重新为切片分配容量，容量大小为原来的两倍`。

上面我们介绍了，可以`使用append函数给切片增加元素`，现在我们再来介绍一个`copy函数用来从一个切片拷贝元素到另一个切片`。

 1 package main
 2 
 3     import (
 4         "fmt"
 5     )
 6 
 7     func main() {
 8         slice1 := []int{1, 2, 3, 4, 5, 6}
 9         slice2 := make([]int, 5, 10)
10         copy(slice2, slice1)
11         fmt.Println(slice1)
12         fmt.Println(slice2)
13     }

输出结果

[1 2 3 4 5 6]
[1 2 3 4 5]

在上面的例子中，我们将slice1的元素拷贝到slice2，因为slice2的长度为5，所以最多拷贝5个元素。

总结一下，数组和切片的区别就在于`[]`里面是否有数字或者`...`。因为数值长度是固定的，而切片是可变的。