起風時&李璇 作品
我們總是喜歡拿“順其自然”來敷衍人生道路上的荊棘坎坷，卻很少承認，真正的順其自然，其實是竭盡所能之后的不強求，而非兩手一攤的不作為。 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
}
在閱讀<Golang入門指南>這本書時，對切片又有了一些新認識。
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
