slice in golang

在go语言中，数组是有特定长度和元素类型共同组成的一种类型，比如[4]int表示4个integer。而[4]int和[5]int是两个完全不同的类型！

slice

slice是基于数组构建的，在数组的基础上提供了更多的操作和便利方法。在go语言的源码中，slice的定义如下：

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

// An notInHeapSlice is a slice backed by go:notinheap memory.
type notInHeapSlice struct {
    array *notInHeap
    len   int
    cap   int
}

对于第二个notInHeapSlice的声明，对golang内存管理感兴趣的同学可以自行查阅相关资料。这里不多做介绍，但是整体来说slice的结构如下：

slice的结构

也就是说slice是数组的一个表示方式，其内部使用一个指针指向一个数组；并用len表示表示数组中元素个数，cap表示该slice能容纳的最大元素个数。

创建slice

1. nil slice
   所谓nil slice就是创建slice之后不对其进行任何初始化，此时该slice就是nil，一个nil slice的len和cap都为0。

var s []int
len(s) //0
cap(s) //0

2. make函数
   make函数的签名如下：
   make([]T, len, cap) []T
   其中cap参数可以缺省，若是这样默认的cap值为len。

// use make function
s := make([]int, 5, 5)
// now s is [0, 0, 0, 0, 0]

3. 基本声明
   基本声明是 s := [len]Type。

nums := [5]int
// now nums is [0, 0, 0, 0, 0]
for i := 0; i < len(nums); i++ {
    nums[i] = i + 1  
}
// now nums is [1, 2, 3, 4, 5]

4. 字面量创建
   除了使用基本的声明方式或make函数外，go也为slice提供了字面量方式。

nums := [5]int{1, 2, 3, 4, 5}
letters := [4]string{"a", "b", "c", "d"}

使用字面量时，可以省略方括号中的长度参数，编译器会自动帮你统计长度。

districts := [...]string{"yuzhong", "nanan", "jiangbei", "beibei"}
cities := []string{"shanghai", "beijing", "tianjin"}

访问

slice和数组一样，可以使用下标进行访问或修改值。

s := []int{1, 0, 3, 4}
// now s is [1, 0, 3, 4]

s[1] = 2 // set value of 2nd element to 2
// now s is [1, 2, 3, 4]

num := s[2]
// num is 3

slice(切片)操作

slice在数组的基础上，增加了切片操作，方便快速的访问或是修改slice。其基本操作方式如下：
slice[start:end]
方括号确定了一个半开区间，也就是[start, end)。比如slice[2:5]切片的范围如下：

slice[2:5]

1. 缺省start
   则默认的start为0，表示从第一个元素开始一直到指定的end前进行切片。比如slice[:6]切片的范围如下：
   
   

   slice[:6]

2. 缺省end
   则默认的end为len(slice)，也就是从开始位置到slice的最后一个元素进行切片。比如slice[2:]切片范围如下：

   
   
   

   slice[2:]

3. 同时缺省
   切取整个slice，也就是 slice[:] = slice。

   
   
   

   slice[:]

看看代码例子：

s := []int{2, 3, 4, 5, 6, 7, 8}
l := s[2:6]  // l = [4, 5, 6, 7]
l = s[:4] // l = [2, 3, 4, 5]
l = s[2:] // l = [4, 5, 6, 7, 8]
l = s[:] // l = [2, 3, 4, 5, 6, 7, 8]

其他

1. slice是引用类型
   对slice进行复制或切片操作，并不会创建原有slice的拷贝。也就是对切片内的元素进行修改，这个修改的结果也会被原有的slice看到。

s2 := []string{"a", "big", "country"}
xs := s2[1:3]
xs[0] = "super"
fmt.Println(xs) // [super country]
fmt.Println(s2) // [a super country]

2. slice一旦创建，其cap就无法增长
   但是可以通过创建新的slice，对齐进行扩容操作。常见的方式是使用copy函数或append函数。首先看一下使用copy函数进行扩容操作：

s := make([]int, 5, 5)
// create new slice
t := make([]int, len(s), (cap(s) + 1) * 2) // cap(s) + 1  is for avoiding cap(s) = 0
copy(t, s)
s = t

append方法会在slice尾部添加数据，并检查slice是否能容纳新的元素，否则会对齐进行扩容。append默认的扩容策略是扩展为正好容纳所有元素。

s := []string{"c"} // len 1, cap 1
s = append(s, "h") // len 2, cap2
s = append(s, "i", "n", "a") // len 5, cap 5

除此外，还可以append函数连接两个slice：

s1 := []string{"a", "b"}
s2 := []string{"c", "d", "e"}
s1 = append(s1, s2...) // s1 = ["a", "b", "c", "d", "e"]
// equal to s1 = append(s1, s2[0], s2[1], s2[2])

参考资料

1. Go Slices: usage and internals