Go语言基础之切片
前言
Hey，大家好呀，我是星期八，这次咱们继续学习Go基础之切片扒。
为什么需要切片
在原来的时候，我们学过数组，我们知道数组是可以存储很多东西的。
代码
package main
import "fmt"
func main() {
var student_list = [4]string{"张三"， "李四"， "王五，"， "小刘"}
fmt.Println(student_list)
}
上述代码定义了一个数组，并且存了4个值，但是如果存5个值或者更多呢。
package main
import "fmt"
func main() {
//方式一，在创建的时候就多加一个值
// 只能存4个，多了会报错，array index 4 out of bounds [0:4]
//var student_list = [4]string{"张三"， "李四"， "王五，"， "小刘"，"小七"}
//方式二，通过索引方式添加值
var student_list = [4]string{"张三"， "李四"， "王五，"， "小刘"}
//还是会报错，invalid array index 4 (out of bounds for 4-element array)
//student_list[4] = "小七"
fmt.Println(student_list)
}
**结论:**数组只能存储固定长度，不能追加值，如果追加值会报错。
所以，就引出了以下的一个链式存储结构。
切片
切片，在其他语言中，在Python中叫列表，Java中好像也是列表，PHP中也叫列表，只是在Go中叫切片(slice)
切片(列表)在每个编程语言中，都是一个非常通用的存储结构。
属于堆内存存储，其内存分布图如下。
如何验证。
package main
import "fmt"
func main() {
var student_list = []string{"张三"， "李四"} //[]里面没有加长度是切片
var student_list2 = [3]string{"张三"， "李四"， "王五"} //[]里面加长度是数组
fmt.Printf("%p\n"， student_list) //结果:0xc000096440
fmt.Printf("%p\n"， student_list2) //结果:%!p([3]string=[张三 李四 王五])，表示不是地址
}
/*
%p表示直接打印的是变量地址
如果是栈中存储的，是打印不出来地址的，显示%!p，表示不是地址
如果是堆中存储，打印的就直接是地址
*/
**ps:**默认打印，赋值等操作，操作的是栈上面的值，所以堆存储直接打印的就是堆的地址，赋值等其他操作同理
开始使用切片
官话
切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。
切片是一个引用类型(堆存储)，它的内部结构包含地址，长度和容量。切片一般用于快速地操作一块数据集合。
声明切片
语法如下。
方式一(声明变量方式)
语法
var 变量名 []存储类型
例如:
package main
/*
和数组操作方式非常像，[]不加数字，就是切片
*/
func main() {
var student_list []string
var student_list2 []int
var student_list3 []float64
//类型推断方式，后面必须带{}，数组同理
var student_list4 = []string{}
}
方式二(make方式)
语法:
var 变量名 = make([]存储类型， 切片中元素数量， 切片的容量)
变量名 := make([]int， 10， 20)
/*
切片容量不写等于切片元素数量
*/
例如:
package main
import "fmt"
func main() {
var student_list4 = make([]int， 10， 20)
fmt.Println(student_list4)//结果:[0 0 0 0 0 0 0 0 0 0]
}
由数组得到的切片
注:数组得到的，只能是切片
package main
import "fmt"
func main() {
var name_array = [5]int{1， 2， 3， 4， 5}
var name_slice = name_array[1:3] //name_array[1:3]切完值以后，结果只能是切片
fmt.Printf("%T %T\n"， name_array， name_slice)
}
ps:数组通过下标范围([开始下标:结束下标])的方式获取的值，只能是列表，取值包含左下标，不包含右下标
简称顾左不顾右。
向切片中追加元素(增)
终于到了每个语言的必学的环节了，切片的增加操作。
在Go中，向切片中追加值，需要用到append。
package main
import "fmt"
func main() {
var student_list []string
//append追加之后，必须使用student_list再接收
student_list = append(student_list， "张三")
student_list = append(student_list， "李四")
student_list = append(student_list， "王五")
fmt.Println(student_list)
}
ps:apppend之后，必须使用原来的变量再接受一次
一次性增加多个
如果一个列表，需要增加另外一个列表怎么办呢？？？
package main
import "fmt"
func main() {
//var student_list []string
var student_list1 = []string{"张三"， "李四"， "王五"， "小刘"}
var student_list2 = make([]string， 10)
student_list2 = append(student_list2， "八神") //添加一个值
student_list2 = append(student_list2， "八神"， "九尾") //可以添加多个值
student_list2 = append(student_list2， student_list1...)
//下面这种写法，就是上面...所包含的意思，专业叫法叫做打散，
//student_list2 = append(student_list2，"张三"， "李四"， "王五"， "小刘")
fmt.Println(student_list2) //[ 八神 张三 李四 王五 小刘]
}
**注:**可能有人会注意到，八神前面会有很多空格，这个先别着急，后面揭晓。
修改切片中的元素(改)
修改就简单了，同数组。
package main
import "fmt"
func main() {
var names = []string{"张三"， "李四"}
names[1] = "李四666" //修改下标为1的值
fmt.Println(names) //[张三 李四666]
}
删除切片中的元素(删)
比较尴尬的是，Go中的切片，在做删除这个操作，不是太友好。
下面举个例子，希望能看懂，看不懂会用就行。
package main
import "fmt"
func main() {
var names = []string{"张三"， "李四"， "王五"， "小刘"， "七阿"}
//删除索引为2的元素
names = append(names[:2]， names[3:]...) //删除王五
fmt.Println(names) //[张三 李四 小刘 七阿]
}
如果看不懂，没关系，下章会好好捋捋这个。
切片遍历(查)
切片的遍历同数组一样。
package main
import "fmt"
func main() {
var names = []string{"张三"， "李四"， "王五"， "小刘"， "七阿"}
//方式一，标准for循环
for i := 0; i < len(names); i++ {
fmt.Println(names[i])
}
//方式二，for range
for index， value := range names {
//index为下标，value为值
fmt.Println(index， value)
}
}
make疑云
我们知道，可以通过make创建切片。
var names = make([]string，10，10)
这句话表示动态创建了一个切片，切片中的元素数量为10个，切片的容量也为10个。
你有疑惑吗???
切片的数量和容量是什么？？？
他俩什么关系？？？
切片本质
其实切片，终究是一个存储数据的一个东西，目前知道数组是可以存储东西的。
其实切片的本质，还是数组，只不过是Go帮助我们做了一些封装，可以方便的对切片里面的数据增删改查。
例如:
package main
import "fmt"
func main() {
var names = make([]int， 4， 10)
//int类型默认值是0
fmt.Println(names， len(names)， cap(names)) //结果:[0 0 0 0] 4 10
}
理解图。
没错，本质就是指向了一个长一点的数组。
但是这个数组是会自动扩容的，当**容量(cap)**append满了之后，会自动扩容。
现在，我们就知道可，make里面参数的意义了。
注意:在Go中，推荐使用make创建切片，并且在创建时，需要考虑容量，尽可能不触发容量自动扩容机制，提高性能。
为什么切片append之后，前面会有空格
在上一章中，大概有这样一段代码。
package main
import "fmt"
func main() {
var names = make([]int，5，10)
names = append(names，11，23，231)
fmt.Println(names)//[0 0 0 0 0 11 23 231]
}
append之后，前面会有很多0，这是怎么回事。
解释:
在通过make创建切片时，第二个参数是切片元素的数量。
上述代码切片第二个参数是5，表示在创建切片时，前5个就已经有值了，只不过是int默认值0。
所以再append时，是再原有的基础上，添加值的，直到cap满了之后，触发扩容机制。
如图所示。
现在，清晰了把。
那怎么append时，从0开始呢？？？
这不是很简单，直接让第二个参数为0。
var names = make([]int，0，10)
//结果:[11 23 231]
如图所示。
好了，这个，懂了吧，怎么继续哈。
为什么不推荐使用var []类型方式创建切片
我们上述一直在提一个词，自动扩容。
我们来看这样一段普通的代码。
package main
import "fmt"
func main() {
var names []int
//地址:0x0，长度(len):0，容量(cap):0
fmt.Printf("地址:%p，长度(len):%d，容量(cap):%d\n"， names， len(names)， cap(names))
names = append(names， 1， 2， 3)
//地址:0xc000010380，长度(len):3，容量(cap):4
fmt.Printf("地址:%p，长度(len):%d，容量(cap):%d\n"， names， len(names)， cap(names))
}
虽然按照这种方法，使用append动态添加是没问题的。
在不使用make声明数组时，len和cap都是0，并且地址也是一个值。
通过append之后，可以明显看到，地址发生了改变，因为又重新申请了数组，切片重新指向新的数组。
len和cap也发生了变化。
copy复制切片
package main
import "fmt"
func main() {
var names1 = make([]string， 0， 10)
names1 = append(names1， "张三")
names1 = append(names1， "李四")
var names2 = names1 //将names1赋值到names2
fmt.Println(names1， names2) //[张三 李四] [张三 李四]
names1[0] = "张三666"//修改names下标为0的值为 张三666
fmt.Println(names1， names2) //[张三666 李四] [张三666 李四]
//为什么修改names1的值，会影响names2的值????
}
为什么修改names1的值，会影响names2的值？？？
这个，就又要回到内存分布图了，如图所示。
我们说过很多次，不管是打印，还是赋值等操作，只会操作栈上面存储的值。
当names2=names1时，只会把names1栈上面的地址，给names2。
但是存的时堆上面的地址，终究还是指向了同一个堆。
所以修改names1时，names2也修改了。
那如果不想出现上述问题怎么办???
解决办法:使用copy
package main
import "fmt"
func main() {
var names1 = make([]string， 0， 10)
names1 = append(names1， "张三")
names1 = append(names1， "李四")
//定义一个names2切片用于接收，第二个参数要留空间，names1里面又几个元素，names2第二个参数也要是几
var names2 = make([]string， 2， 10)
copy(names2， names1)//将names1的值，赋值到names2
fmt.Println(names1， names2) //[张三 李四] [张三 李四]
names1[0] = "张三666"//修改names下标为0的值为 张三666
fmt.Println(names1， names2) //[张三666 李四] [张三 李四]
fmt.Printf("names1地址:%p names2地址:%p\n"，names1，names2)
//names1地址:0xc00009a0a0 names2地址:0xc00009a140
}
内存图
自动扩容机制
我不会。。。
总结
上述我们学习了Go基础之切片。
如果在操作过程中有任务问题，记得下面留言，我们看到会第一时间解决问题。
我是码农星期八，如果觉得还不错，记得动手点赞以下哈。
感谢你的观看。
307
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
