不積跬步，無以至千里；不積小流，無以成江海。
碼字不易，點贊再看。
引子
因為數組的長度是 固定 的並且數組長度屬於類型的一部分，所以數組有很多的侷限性。 例如：
<code>func
arraySum
(x [3]
int
)int
{ sum :=0
for
_, v :=range
x{ sum = sum + v }return
sum } /<code>
這個求和函數只能接受[3]int類型，其他的都不支持。 再比如，
<code>a := [3
]int
{1
,2
,3
} /<code>
數組a中已經有三個元素了，我們不能再繼續往數組a中添加新元素了。
切片
切片（Slice）是一個擁有 相同類型 元素的可變長度的序列。它是基於數組類型做的一層封裝。它非常靈活，支持自動擴容。
切片是一個 引用類型，它的內部結構包含 地址、長度 和 容量。切片一般用於快速地操作一塊數據集合。
聲明切片類型的基本語法如下
<code>var
name []T /<code>
其中，
name:表示變量名 T:表示切片中的元素類型
舉個例子：
<code>func
main
()
{var
a []string
var
b = []int
{}var
c = []bool
{false
,true
}var
d = []bool
{false
,true
} fmt.Println(a) fmt.Println(b) fmt.Println(c) fmt.Println(a ==nil
) fmt.Println(b ==nil
) fmt.Println(c ==nil
) } /<code>
切片的長度和容量
切片擁有自己的長度和容量，我們可以通過使用內置的 len() 函數求長度，使用內置的 cap() 函數求切片的容量。
切片表達式
切片表達式有兩種變體：一種指定 low 和 high 兩個索引界限值的簡單的形式，另一種是除了low和high索引界限值外還指定容量的完整的形式。
簡單切片表達式
切片的 底層 就是一個 數組，所以我們可以基於數組通過切片表達式得到切片。 切片表達式中的low和high表示一個索引範圍（左閉，右開），也就是下面代碼中從數組a中選出1<=索引值<3的元素組成切片s，得到的切片長度 = high-low，容量等於得到的切片的底層數組的容量。
<code>func
main
()
{ a := [5
]int
{1
,2
,3
,4
,5
} s := a[1
:3
] fmt.Printf("s:%v len(s):%v cap(s):%v\n"
, s,len
(s),cap
(s)) } /<code>
輸出：
<code>s
:[2 3]
len
(s
):2
cap
(s
):4
/<code>
為了方便起見，可以省略切片表達式中的任何索引。省略了low則默認為0；省略了high則默認為切片操作數的長度:
<code>a
[2:]
a
[:3]
a
[:]
/<code>
完整切片表達式
對於數組，指向數組的指針，或切片a(注意不能是字符串)支持完整切片表達式：
<code>a
[low : high : max]
/<code>
上面的代碼會構造與簡單切片表達式a[low: high]相同類型、相同長度和元素的切片。另外，它會將得到的結果切片的容量設置為 max-low。在完整切片表達式中只有第一個索引值（low）可以省略；它默認為0。
<code>func
main
()
{ a := [5
]int
{1
,2
,3
,4
,5
} t := a[1
:3
:5
] fmt.Printf("t:%v len(t):%v cap(t):%v\n"
, t,len
(t),cap
(t)) } /<code>
輸出結果
<code>t
:[2 3]
len
(t
):2
cap
(t
):4
/<code>
完整切片表達式需要滿足的條件是0 <= low <= high <= max <= cap(a)，其他條件和簡單切片表達式相同。
使用make()函數構造切片
我們上面都是基於數組來創建的切片，如果需要動態的創建一個切片，我們就需要使用內置的make()函數，格式如下：
<code>make
([]T, size,cap
) /<code>
其中：
- T:切片的元素類型
- size:切片中元素的數量
- cap:切片的容量
<code>func
main
() {a
:=make
([]int,2
,10
) fmt.Println
(a) //[0
0
] fmt.Println
(len(a)) //2
fmt.Println
(cap(a)) //10
} /<code>
上面代碼中a的內部存儲空間已經分配了10個，但實際上只用了2個。 容量並不會影響當前元素的個數，所以len(a)返回2，cap(a)則返回該切片的容量。
切片的本質
切片的本質就是 對底層數組的封裝，它包含了三個信息：底層數組的指針、切片的長度（len）和切片的容量（cap）。
舉個例子，現在有一個數組a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片s1 := a[:5]，相應示意圖如下。
判斷切片是否為空
要檢查切片是否為空，請始終使用 len(s) == 0 來判斷，而不應該使用s == nil來判斷。
切片之間是 不能 比較的，我們不能使用==操作符來判斷兩個切片是否含有全部相等元素。 切片唯一合法的比較操作是和nil比較。 一個nil值的切片並沒有底層數組，一個nil值的切片的長度和容量都是0。但是我們不能說一個長度和容量都是0的切片一定是nil，例如下面的示例：
<code>var
s1 []int
s2 := []int
{} s3 :=make
([]int
,0
) /<code>
所以要判斷一個切片是否是空的，要是用 len(s) == 0 來判斷，不應該使用s == nil來判斷。
切片的賦值拷貝
下面的代碼中演示了拷貝前後兩個變量 共享
底層數組，對一個切片的修改會影響另一個切片的內容，這點需要特別注意。<code>func
main
()
{ s1 :=make
([]int
,3
) s2 := s1 s2[0
] =100
fmt.Println(s1) fmt.Println(s2) } /<code>
切片遍歷
切片的遍歷方式和數組是一致的，支持索引遍歷和for range遍歷。
<code>func
main
()
{ s := []int
{1
,3
,5
}for
i :=0
; ilen
(s); i++ { fmt.Println(i, s[i]) }for
index, value :=range
s { fmt.Println(index, value) } } /<code>
append()方法為切片添加元素
Go語言的內建函數 append()可以為切片動態添加元素。 可以一次添加一個元素，可以添加多個元素，也可以添加另一個切片中的元素（後面加…）。
<code>func
main(){
var
s
[]int
s
=
append(s,
1
)
//
[1]
s
=
append(s,
2
,
3
,
4
)
//
[1
2
3
4
]
s2
:=
[]int{5,
6
,
7
}
s
=
append(s,
s2...)
//
[1
2
3
4
5
6
7
]
}
/<code>
注意：通過var聲明的零值切片可以在append()函數直接使用，無需初始化。
<code>var
s []int
s =append
(s,1
,2
,3
) /<code>
沒有必要像下面的代碼一樣初始化一個切片再傳入append()函數使用，
<code>s := []int
{} s =append
(s,1
,2
,3
)var
s =make
([]int
) s =append
(s,1
,2
,3
) /<code>
每個切片會指向一個底層數組，這個數組的容量夠用就添加新增元素。當底層數組不能容納新增的元素時，切片就會自動按照一定的策略進行“擴容”，此時該切片指向的底層數組就會更換。“擴容”操作往往發生在append()函數調用時，所以我們通常都需要用原變量接收append函數的返回值。
舉個例子：
<code>func
main
()
{var
numSlice []int
for
i :=0
; i10
; i++ { numSlice =append
(numSlice, i) fmt.Printf("%v len:%d cap:%d ptr:%p\n"
, numSlice,len
(numSlice),cap
(numSlice), numSlice) } } /<code>
<code>[0]
len:1
cap:1
ptr:0xc00001a150
[0
1
]
len:2
cap:2
ptr:0xc00001a170
[0
1
2
]
len:3
cap:4
ptr:0xc0000181e0
[0
1
2
3
]
len:4
cap:4
ptr:0xc0000181e0
[0
1
2
3
4
]
len:5
cap:8
ptr:0xc0000200c0
[0
1
2
3
4
5
]
len:6
cap:8
ptr:0xc0000200c0
[0
1
2
3
4
5
6
]
len:7
cap:8
ptr:0xc0000200c0
[0
1
2
3
4
5
6
7
]
len:8
cap:8
ptr:0xc0000200c0
[0
1
2
3
4
5
6
7
8
]
len:9
cap:16
ptr:0xc000104000
[0
1
2
3
4
5
6
7
8
9
]
len:10
cap:16
ptr:0xc000104000
/<code>
從上面的結果可以看出：
- append()函數將元素追加到切片的最後並返回該切片。
- 切片numSlice的容量按照1，2，4，8，16這樣的規則自動進行擴容，每次擴容後都是擴容前的2倍。
使用copy()函數複製切片
首先我們來看一個問題：
<code>func
main()
{
a
:=
[]int{1,
2
,
3
,
4
,
5
}
b
:=
a
fmt.Println(a)
//[1
2
3
4
5
]
fmt.Println(b)
//[1
2
3
4
5
]
b[0]
=
1000
fmt.Println(a)
//[1000
2
3
4
5
]
fmt.Println(b)
//[1000
2
3
4
5
]
}
/<code>
由於切片是引用類型，所以a和b其實都指向了同一塊內存地址。修改b的同時a的值也會發生變化。
Go語言內置的 copy() 函數可以迅速地將一個切片的數據複製到另外一個切片空間中，copy()函數的使用格式如下：
copy(destSlice, srcSlice []T)
其中：
- srcSlice: 數據來源切片
- destSlice: 目標切片
舉例：
<code>func
main()
{
//
copy()複製切片
a
:=
[]int{1,
2
,
3
,
4
,
5
}
c
:=
make([]int,
5
,
5
)
copy(c,
a)
//使用copy()函數將切片a中的元素複製到切片c
fmt.Println(a)
//[1
2
3
4
5
]
fmt.Println(c)
//[1
2
3
4
5
]
c[0]
=
1000
fmt.Println(a)
//[1
2
3
4
5
]
fmt.Println(c)
//[1000
2
3
4
5
]
}
/<code>
從切片中刪除元素
Go語言中並沒有刪除切片元素的專用方法，我們可以使用切片本身的特性來刪除元素。 代碼如下：
<code>func
main()
{
//
從切片中刪除元素
a
:=
[]int{30,
31
,
32
,
33
,
34
,
35
,
36
,
37
}
//
要刪除索引為2的元素
a
=
append(a[:2],
a[3:]...)
fmt.Println(a)
//[30
31
33
34
35
36
37
]
}
/<code>
總結一下就是：要從切片a中刪除索引為index的元素，操作方法是 a = append(a[:index], a[index+1:]...)
點關注 不迷路
如果你從本篇內容有收穫，求 點贊，求 關注，求 轉發 ，讓更多的人學習到。
如果本文有任何錯誤，請批評指教，不勝感激
