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