前言
Go中的数组数据类型的长度在声明之后就无法修改了，切片是基于数组实现的，切片是动态数组，切片是1种可变长度的序列。它支持扩容。
切片不保存值，只保存（len、cap、底层数组的指针），在底层引用数组的值也就是引用数据类型，
接触了Go中arry、slice，会感觉到Python里面的list数据类型是如此的便捷，感谢Python的作者吧。
Go相对于Python来说是比较偏向底层的语言，为什么只能在arry、slice中只能存相同数据类型的值，是因为Go仅仅选中1块连续的内存地址。
而Python的list可以存不同的数据类型，是因为Python解释器会帮我们通过算法查找散列在 不连续内存上的不同内存地址来获取值。
所以Go执行效率高，但是Python开发效率高。
切片和数组不同的是：
每个切片底层都对应1个数组，为这个切片存值， 所以slice类型变量 在没有初始化前没有分配内存、所以就根本没有默认值 =nil，因为你没有初始化指定长度和元素的数据类型，怎么给你分配这个底层数组呢？
//声明1个数组变量 var a1 [3]int fmt.Println(a1)//声明完了就有默认值 //声明1个切片类型的变量 var s1 []int fmt.Println(s1 == nil)
引子
为什么在Go中有了数组，还需要1个可变长度的切片呢？因为数组需要支持扩容！
package main
import "fmt"
func arraySum(x [3]int) int {
sum := 0
for _, v := range x {
sum = sum + v
}
return sum
}
func main() {
a1 := [3]int{1, 2, 3}
//如果函数的参数定义了参数的长度，只能传长度为3的数组，所以数组有一定的局限性
total := arraySum(a1)
fmt.Println(total)
}
//.\main.go:14:24: array index 3 out of bounds [0:3]
切片的定义和初始化
切片类型和数组类型一样，想要使用，就必须要定义和初始化，不同之处已经提到，切片不需要指定切片的长度。
自定义切片
package main
import (
"fmt"
)
func main() {
//切片的定义
var s1 []int //存放元素不限定，仅限定数据类型
var s2 []string
fmt.Println(s1 == nil) //在初始化之前切片的值=nil
fmt.Println(s2 == nil)
//切片的初始化
s1 = []int{1, 2, 3}
s2 = []string{"刘德华", "郭富城", "黎明", "梁朝伟"}
//切片的长度和容量
fmt.Printf("长度：%d 容量：%d", len(s1), cap(s1))
}
由数组得到切片 slice := arry [ : ]
package main
import "fmt"
var a1 [3]string
func main() {
a1 = [3]string{"a", "b", "c"}
// fmt.Printf("%T\n", a1)
s1:=a1[:]//数组变成了1个切片,但是使用a1数组存储数据！
// fmt.Printf("%T\n", a1)
s1[0]="1"
s1[1]="2"
s1[2]="3"
// s1[3]="4"
// s1[5]="5"
fmt.Println(s1)
}
package main
import (
"fmt"
)
func main() {
a1 := [...]int{1, 2, 3, 4, 5, 6, 69}
s1 := a1[0:2]
s2 := a1[:4]
s3 := a1[2:]
s4 := a1[:]
fmt.Println(s1, s2, s3, s4)
//切片的容量:是指底层数组的从切边的第1个元素-----》最后1个元素的数量
fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s1), cap(s1))
fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s2), cap(s2))
fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s3), cap(s3))
}
切片的内存管理机制
如果我对切片A再进行切片([区间])或者变量赋值就会拿到1个新的切片B，如果给切片B追加元素那么会影响会怎样呢？
如果我们对切片B进行了appen，那么B的lengh就会不同于A。
如果没有超出容量，切片A、B会同用1个底层数组。
如果超出了原来容量则创建新的底层数组以支撑这个新的切片。
v1 := make([]int, 3, 5) fmt.Println(v1,len(v1),cap(v1)) //v1=[0 0 0] v2 := append(v1, 8) fmt.Println(v2,len(v2),cap(v2)) //v2=[0 0 0 8] fmt.Println(v1,len(v1),cap(v1)) //v2切片的长度经过append之后len=4,切片v1(不同于v2)的长度还是3,他的len决定了v1不会看到8 //[0 0 0] //[0 0 0 8] //[0 0 0]
在Python里面对列表进行切片会开辟1块内存地址存储产生的新列表肯定不会影响。
在golang中如果对切片的切片进行apend操作，append的值会直接覆盖底层数组中值。
Go会.........因为你对1个切片，切几次产生的 “新”切片，只是指针、长度不同，本质都引用了同1个底层数组。
//6.删除元素：go语言没有直接删除切片元素的API var numberList= []string{"a","b","c","c","d","e"} deleteIndex:=2 //删除c：切片numberList的切片["a","b"]追加了["c","d","e"]相当于操作了底层数组把原来的c、c、d覆盖成了c、d、e numberList=append(numberList[0:deleteIndex],numberList[deleteIndex+1:]...) //本质原因还是切片numberList和切片numberList的切片["a","b"]共同引用了同1个底层数组 fmt.Println(numberList)
切片自动扩容的内存管理机制
1.每1个切片底层都对应了1个数组来保存值，而切片保存这个底层数组的长度（len）、容量（ cap）、底层数组的位置 （point）。
v1:=make([]int,1,3) fmt.Println(len(v1),cap(v1))
2.切片append元素（不产生扩容的情况）
切片追加元素时，在不会产生扩容的情况下，append之后产生的新切片和原切片引用同1个底层数组。
所以对切片进行再次切片时产生的新切片们，本质上就是引用的还是1个底层数组，只不过它们的长度不同，从这块内存上获取数据的起始位置不一样。
v1:=make([]int,1,3) v2:=append(v1,66) //返回新的切片v2 fmt.Println(v1) //[0] fmt.Println(v2) //[0,66] v1[0]=99 fmt.Println(v1) //[99] fmt.Println(v2) //[99 66] fmt.Printf("v1的内存地址：%p,v2的内存地址:%p。",v1,v2)
3.切片在追加（append）元素时，出现了扩容。
一旦出现了扩容就会产生1个新的底层数组来保存原来的数据和新的数据。
所以新、旧切片使用了2个不同的底层数组。它们之间的修改操作不再彼此影响！
v1 :=[]int{11,22,33} //创建1个切片长度为3，容量为3 fmt.Printf("%v 的长度为：%d,容量为%d.\n",v1,len(v1),cap(v1))
--------------------------------------------------------------- v2:=append(v1,44) //apend时产生了扩容，长度为4，容量为6 fmt.Printf("%p\n",v2) v1[0]=101 v2[0]=222 fmt.Printf("%v的长度为：%d,容量为%d.\n",v1,len(v1),cap(v1)) fmt.Printf("%v的长度为：%d,容量为%d.\n",v2,len(v2),cap(v2))
切片为引用类型论证
Go中的切片底层都有1个数组支撑， 切引用这个底层数组的值，所以底层数组改变，切片的值也改变；
// package main
// import (
// "fmt"
// )
// func main() {
// //切片的定义
// var s1 []int //存放元素不限定，仅限定数据类型
// var s2 []string
// fmt.Println(s1 == nil) //在初始化之前切片的值=nil
// fmt.Println(s2 == nil)
// //切片的初始化
// s1 = []int{1, 2, 3}
// s2 = []string{"刘德华", "郭富城", "黎明", "梁朝伟"}
// //切片的长度和容量
// fmt.Printf("长度：%d 容量：%d", len(s1), cap(s1))
// }
// package main
// import (
// "fmt"
// )
// func main() {
// a1 := [...]int{1, 2, 3, 4, 5, 6, 69}
// s1 := a1[0:2]
// s2 := a1[:4]
// s3 := a1[2:]
// s4 := a1[:]
// fmt.Println(s1, s2, s3, s4)
// //切片的容量:是指底层数组的从切边的第1个元素-----》最后1个元素的数量
// fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s1), cap(s1))
// fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s2), cap(s2))
// fmt.Printf("切片的长度：%d 切片的容量：%d\n", len(s3), cap(s3))
// }
package main
import (
"fmt"
)
func main() {
a1 := [...]int{1, 2, 3, 4}
s1 := a1[:3]
fmt.Println(s1)
a1[0] = 666 //修改了a1数组，但是s1引用着a1
s2 := a1[:3]
fmt.Println(s2)
}
切片常见操作
package main import "fmt" func main() { //1.获取切片的长度和容量 var userList = []string{"alex", "eric", "润洪涛"} fmt.Println(len(userList), cap(userList)) //2.s索引获取和修改值 fmt.Println(userList[0]) userList[0] = "李杰" fmt.Println(userList) //3.切片再切片:本质上引用同1个底层数组，但起始位置不一致 v1 := userList[0:2] v2 := userList[1:] v3 := userList[:3] fmt.Println(v1, v2, v3) //4.切片追加元素 v4:=append(userList,"小明","二狗","小刚子") fmt.Printf("%p---%p\n",userList,v4) //5.切片合并 var extendList=[]string{"小何","小黑"} v5:=append(userList,extendList ...) fmt.Printf("%p----%p\n",userList,v5) fmt.Println(v5) //6.切片删除元素：go语言没有直接删除切片元素的API var numberList= []string{"a","b","c","c","d","e"} deleteIndex:=2 //删除c：切片numberList的切片["a","b"]追加了["c","d","e"]相当于操作了底层数组把原来的c、c、d覆盖成了c、d、e numberList=append(numberList[0:deleteIndex],numberList[deleteIndex+1:]...) //本质原因还是切片numberList和切片numberList的切片["a","b"]共同引用了同1个底层数组 fmt.Println(numberList) //7.切片插入元素 var userList1= []string{"a","b","d","e"} insertIndex:=2 newUserList:=make([]string,0,len(userList1)+1) //长度=0，数组中没数据，就是不初始化值=[] newUserList=append(newUserList,userList1[:insertIndex]...) newUserList=append(newUserList,"c") newUserList=append(newUserList,userList1[insertIndex:]...) fmt.Println(numberList) //错误的想法 result:=append(userList1[:insertIndex],"c") result=append(result,userList1[insertIndex:]...) fmt.Println(result) //8.循环切片 for i:=0;i<len(newUserList);i++{ fmt.Println(newUserList[i]) } //8.for range collection for i, v := range newUserList { fmt.Println(i,v) } }