go語言學習 slice切片

定義

切片（Slice）是一個擁有相同類型元素的可變長度的序列。它是基于數組類型做的一層封裝。它非常靈活，支援自動擴容。

切片是一個引用類型，它的内部結構包含

位址

、

長度

和

容量

。切片一般用于快速地操作一塊資料集合。

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<=索引值<4

的元素組成切片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))
}
           

為了友善起見，可以省略切片表達式中的任何索引。省略了

low

則預設為0；省略了

high

則預設為切片操作數的長度:

a[2:]  // 等同于 a[2:len(a)]
a[:3]  // 等同于 a[0:3]
a[:]   // 等同于 a[0:len(a)]
           

對于數組或字元串，如果

0 <= low <= high <= len(a)

，則索引合法，否則就會索引越界（out of range）。

對切片再執行切片表達式時（切片再切片），

high

的上限邊界是切片的容量

cap(a)

，而不是長度。常量索引必須是非負的，并且可以用int類型的值表示;對于數組或常量字元串，常量索引也必須在有效範圍内。如果

low

和

high

兩個名額都是常數，它們必須滿足

low <= high

。如果索引在運作時超出範圍，就會發生運作時

panic

。

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))
	s2 := s[3:4]  // 索引的上限是cap(s)而不是len(s)
	fmt.Printf("s2:%v len(s2):%v cap(s2):%v\n", s2, len(s2), cap(s2))
}
           

完整切片表達式

對于數組，指向數組的指針，或切片a(注意不能是字元串)支援完整切片表達式：

a[low : high : max]
           

上面的代碼會構造與簡單切片表達式

a[low: high]

相同類型、相同長度和元素的切片。

另外，它會将得到的結果切片的容量設定為

max-low

。在完整切片表達式中隻有第一個索引值（low）可以省略；它預設為0。

完整切片表達式需要滿足的條件是

0 <= low <= high <= max <= cap(a)

，其他條件和簡單切片表達式相同。

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))
}
           

使用make()函數構造切片

如果需要動态的建立一個切片，我們就需要使用内置的

make()

函數，格式如下：

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)

則傳回該切片的容量。

判斷切片是否為空

切片之間是不能比較的，我們不能使用

==

操作符來判斷兩個切片是否含有全部相等元素。 切片唯一合法的比較操作是和

nil

比較。 一個

nil

值的切片并沒有底層數組，一個

nil

值的切片的長度和容量都是0。但是我們不能說一個長度和容量都是0的切片一定是

nil

，例如下面的示例：

var s1 []int         //len(s1)=0;cap(s1)=0;s1==nil
s2 := []int{}        //len(s2)=0;cap(s2)=0;s2!=nil
s3 := 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]
}
           

切片周遊

周遊方式與數組一緻

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方法添加元素

可以一次添加一個元素，可以添加多個元素，也可以添加另一個切片中的元素（後面加…）。

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 []int
s = append(s, 1, 2, 3)
           

每個切片會指向一個底層數組，這個數組的容量夠用就添加新增元素。

當底層數組不能容納新增的元素時，切片就會自動按照一定的政策進行“擴容”，此時該切片指向的底層數組就會更換。

“擴容”操作往往發生在

append()

函數調用時，是以我們通常都需要用原變量接收append函數的傳回值。 

1. append()

   函數将元素追加到切片的最後并傳回該切片。
2. 切片numSlice的容量按照1，2，4，8，16這樣的規則自動進行擴容，每次擴容後都是擴容前的2倍。

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)
	}
}
           

append()函數還支援一次性追加多個元素。 例如：

var citySlice []string
// 追加一個元素
citySlice = append(citySlice, "北京")
// 追加多個元素
citySlice = append(citySlice, "上海", "廣州", "深圳")
// 追加切片
a := []string{"成都", "重慶"}
citySlice = append(citySlice, a...)
fmt.Println(citySlice) //[北京 上海 廣州 深圳 成都 重慶]
           

 使用copy()函數複制切片

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語言中并沒有删除切片元素的專用方法，我們可以使用切片本身的特性來删除元素。

要從切片a中删除索引為

index

的元素，操作方法是

a = append(a[:index], a[index+1:]...)

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]
}