起风时&李璇 作品
我们总是喜欢拿“顺其自然”来敷衍人生道路上的荆棘坎坷，却很少承认，真正的顺其自然，其实是竭尽所能之后的不强求，而非两手一摊的不作为。 by 瑞卡斯
引用于：http://wufazhuce.com/one/1353
slice 知识要点
- ** slice 是引用类型，所以当引用改变其中元素的值时，其它的所有引用都会改变该值**。
- ** slice 在未初始化之前默认为 nil，长度为 0**。
- slice 的声明格式：
var identifier []type（不需要说明长度）。 - slice 初始化格式：
4.1.var sliceName []type = arrName[start:end]（通过数组初始化切片）。
4.2.var sliceName []type = make([]type, len, cap)（cap可选参数）。
4.3.a := []int(1, 2)（已知道元素值情况下初始化切片）。 - slice 像一个结构体，这个结构体包含了三个元素
5.1. 一个指针，指向数组中 slice 指定的开始位置。
5.2.len长度，即 slice 的长度。
5.3.cap最大长度，也就是 slice 开始位置到数组的最后位置的长度。 - 尽可能的用切片代替数组
- 使用
make([]type, 0)实例化一个空的切片。
例如：下面示例和视图
Array_a := [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
Slice_a := Array_a[2:5]
slice示例图
slice和数组在声明时的区别：声明数组时，方括号内写明了数组的长度或使用...自动计算长度，而声明slice时，方括号内没有任何字符。
slice 的一些简便操作
- slice 的默认开始位置是
0，ar[:n]等价于ar[0:n]。 - slice 的第二个序列默认是数组的长度，
ar[n:]等价于ar[n:len(ar)]。 - 如果从一个数组里面直接获取 slice，可以这样
ar[:]，因为默认第一个序列是0，第二个是数组的长度，即等价于ar[0:len(ar)]。
slice和array的对应关系图
func printSliceByRange(s []int) {
for k, v := range s {
fmt.Printf("s[%d]=%d ", k, v)
}
fmt.Println()
}
func printSliceByLen(s []int) {
for i, j := 0, len(s); i < j; i++ {
fmt.Printf("s[%d]=%d ", i, s[i])
}
fmt.Println()
}
/*
数组[a:b]
创建一个包含数组的第a个元素到第b-1个元素的切片。
当前长度 = b - a
最大容量 = len(数组) - a
slice是引用类型，所以当引用改变其中元素的值时，其它的所有引用都会改变该值
*/
func main() {
//通过指向一个数组声明并初始化slice
arr := [5]int{1, 2, 3, 4, 5}
//等价于sliceA := arr[0:5]
//包含arr的全部元素{1, 2, 3, 4, 5}
//len = 5，cap = 5
sliceA := arr[:]
//等价于sliceA := arr[0:4]
//包含arr的全部元素{1, 2, 3, 4}
//len = 4，cap = 5
sliceA = arr[:4]
//等价于sliceA := arr[3:5]
//包含arr的全部元素{4, 5}
//len = 2，cap = 2
sliceA = arr[3:]
//包含arr的全部元素{2, 3, 4}
//len = 3，cap = 4
sliceA = arr[1:4]
//通过make声明并初始化slice
//指向一个int类型数组，默认长度为2，最大容量为10
sliceB := make([]int, 2, 10)
printSliceByRange(sliceA) //s[0]=2 s[1]=3 s[2]=4
printSliceByLen(sliceB) //s[0]=0 s[1]=0
//append函数会改变slice所引用的数组的内容，从而影响到引用同一数组的其它slice。
//但当slice中没有剩余空间（即(cap-len) == 0）时，此时将动态分配新的数组空间。
//返回的slice数组指针将指向这个空间，而原数组的内容将保持不变；其它引用此数组的slice则不受影响。
sliceA = arr[:]
sliceC := append(sliceA, 6)
printSliceByRange(sliceA) //s[0]=1 s[1]=2 s[2]=3 s[3]=4 s[4]=5
printSliceByRange(sliceC) //s[0]=1 s[1]=2 s[2]=3 s[3]=4 s[4]=5 s[5]=6
}
在阅读
这本书时，对切片又有了一些新认识。
slice 结合append、copy函数使用
- 将切片b追加到切片a之后。
temp_as = append(temp_as, temp_bs...) - 复制切片a的元素到新的切片b上。
copy(temp_cs, temp_bs) - 删除位于索引i的元素。
append(temp_as[:i], temp_as[i+1:]...) - 切除切片a中从索引j至k位置的元素。
append(temp_as[:j], temp_as[k:]...) - 将元素b追加到切片a。
append(temp_as, b)
func demo7() {
//将切片b追加到切片a之后
temp_a := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
temp_as := temp_a[:]
temp_b := [5]int{10, 11, 12, 13, 14}
temp_bs := temp_b[:]
temp_as = append(temp_as, temp_bs...)
fmt.Println(temp_as) //[0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
//复制切片a的元素到新的切片b上
temp_cs := make([]int, 15)
copy(temp_cs, temp_bs)
fmt.Println(temp_cs) //[10 11 12 13 14 0 0 0 0 0 0 0 0 0 0]
//删除位于索引5的元素
temp_as = append(temp_as[:5], temp_as[6:]...)
fmt.Println(temp_as) //[0 1 2 3 4 6 7 8 9 10 11 12 13 14]
//切除切片a中从索引3至6位置的元素
temp_as = append(temp_as[:3], temp_as[6:]...)
fmt.Println(temp_as) //[0 1 2 7 8 9 10 11 12 13 14]
//将元素15追加到切片a
temp_as = append(temp_as, 15)
fmt.Println(temp_as) //[0 1 2 7 8 9 10 11 12 13 14 15]
}
切片和垃圾回收
切片的底层指向一个数组，该数组的实际体积可能要大于切片所定义的体积。只有在没有任何切片指向的时候，底层的数组内层才会被释放，这种特性有时会导致程序占用多余的内存。
示例 函数FindDigits将一个文件加载到内存，然后搜索其中所有的数字并返回一个切片。
var digitRegexp = regexp.MustCompile("[0-9]+")
func FindDigits(filename string) []byte {
b, _ := ioutil.ReadFile(filename)
return digitRegexp.Find(b)
}
这段代码可以顺利运行，但返回的[]byte指向的底层是整个文件的数据。只要该返回的切片不被释放，垃圾回收器就不能释放整个文件所占用的内存。换句话说，一点点有用的数据却占用了整个文件的内存。
想要避免这个问题，可以通过拷贝我们需要的部分到一个新的切片中：
func FindDigits(filename string) []byte {
b, _ := ioutil.ReadFile(filename)
b = digitRegexp.Find(b)
c := make([]byte, len(b))
copy(c, b)
return c
}
参考：
https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/02.2.md