Go的切片「卧槽，你怎么跟数组长得差不多？」

什么是切片？？这个问题，给初学的我，造成了一些困扰
查找了一些文章，在不去论述底层的情况，就浅层来说

“切片就是可变长的数组”

定义的一般形式

格式

var 变量名 []变量类型

例子，其中包括默认输出

package main

import "fmt"

func main(){

	var testSlice []int

	fmt.Println("切片的默认值为：", testSlice)
}
/*
输出：切片的默认值为： []
*/

---

利用 make() 函数定义切片

格式yi

make([]Type, length)

格式er

make([]Type, Length, capacity)

例子

package main

import "fmt"

func main(){

	var testOne = make([]int, 5)

	var testTwo = make([]int, 5, 15)

	fmt.Println("testOne的len为：", len(testOne))
	fmt.Println("testTwo的len为：", len(testTwo))

	fmt.Println("testOne的cap...为", cap(testOne))
	fmt.Println("testOne的cap...为", cap(testTwo))
}
/*
输出：
	testOne的len为： 5
	testTwo的len为： 5
	testOne的cap...为 5
	testOne的cap...为 15
*/

创建切片的时候，在没指定容量「capacity」的情况下，容量等同于长度

len()：获取长度
cap()：查看切片最长可以达到多少

---

初始化

一般形式的初始化

package main

import "fmt"

func main(){

	var testSliceInit = []int{1, 2, 3, 4, 5, 6}

	fmt.Println(len(testSliceInit),"为len")
	fmt.Println(cap(testSliceInit),"为cap")
}
/*
输出：
	6 为len
	6 为cap
*/

利用推断初始化

package main

import "fmt"

func main(){

	testSlice := []int{0, 1, 2, 3, 4}

	fmt.Println("len：", len(testSlice))
	fmt.Println("cap：", cap(testSlice))
}
/*
输出：
	len： 5
	cap： 5
*/

---

如何在切片中追加元素

需使用函数

append(slice []Type, elems ...Type)

例子

package main

import "fmt"

func main(){

	testSlice := []int{0, 1, 2, 3, 4}

	fmt.Print("追加前的输出：")
	for i := 0; i < len(testSlice); i++  {
		fmt.Print(" ", testSlice[i])
	}

	
	testSlice = append(testSlice, 5)
	testSlice = append(testSlice, 6)
	testSlice = append(testSlice, 7)
	/*
	上面三行等于：
		testSlice = append(testSlice, 5, 6, 7)
	*/


	fmt.Print("\n追加后的输出：")
	for i := 0; i < len(testSlice); i++  {
		fmt.Print(" ", testSlice[i])
	}
}
/*
输出：
	追加前的输出： 0 1 2 3 4
	追加后的输出： 0 1 2 3 4 5 6 7
*/

---

如何复制一个切片

需使用函数

func copy(dst, src []Type)

第一个参数，需要复制的切片
第二个参数，被复制的切片

例子

package main

import "fmt"

func main(){

	copyBefore := []int{0, 1, 2, 3, 4}


	copyAfter := make([]int, len(copyBefore), cap(copyBefore))

	copy(copyAfter, copyBefore)

	fmt.Print("\ncopyAfter：")
	for i := 0; i < len(copyAfter); i++  {
		fmt.Print(" ", copyAfter[i])
	}
}
/*
输出：
	copyAfter： 0 1 2 3 4
*/

在复制的时候要注意：

• 复制者的 cap 要大于等于被复制者
• 至于长度是多少，这倒是无所谓，填在 cap的范围内，都不会报错
• 复制者的 len 大于等于 被复制者，所有元素都能复制
• 复制者的 len 小于 被复制者，小多少，后面的元素就少复制多少

---

切片的截取

package main

import "fmt"

func main(){

	initialSlice := []int{0, 1, 2, 3, 4}

	split1 := initialSlice[:]
	split2 := initialSlice[1:]
	split3 := initialSlice[:len(initialSlice) - 1]

	fmt.Printf("initialSlice --> len=%d cap=%d slice=%v\n",len(initialSlice),cap(initialSlice),initialSlice)
	fmt.Printf("split1 --> len=%d cap=%d slice=%v\n",len(split1),cap(split1),split1)
	fmt.Printf("split2 --> len=%d cap=%d slice=%v\n",len(split2),cap(split2),split2)
	fmt.Printf("split3 --> len=%d cap=%d slice=%v\n",len(split3),cap(split3),split3)
}
/*
输出：
	initialSlice --> len=5 cap=5 slice=[0 1 2 3 4]
	split1 --> len=5 cap=5 slice=[0 1 2 3 4]
	split2 --> len=4 cap=4 slice=[1 2 3 4]
	split3 --> len=4 cap=5 slice=[0 1 2 3]
*/

需要注意的几点：

• 在 [ : ]中间，有冒号的是切整个切片
• [len : ]左边有值的，从切片的左边这个数开始切
• [ : len]右边有值的，从切片的右边这个数减一开始切
• [ leftLen : rightLen)：包左不包右

---

欢迎大家关注下个人的「公众号」：独醉贪欢