一、概念
1、切片是对数组一个连续片段的引用，所以切片是一个引用类型
2、切片是数组一样可以索引，可以通过len函数获取切片的数据长度。（数组也可以通过len获取）
3、切片是一个长度可变的数组
4、切片有容量的概念，这是数组所没有的，go 提供了计算容量的函数cap(),可以计算切片容量。0 <=len(s) <=cap(s)
优点：
因为切片是引用，所以它不需要额外的内存并且比使用数组更有效率，所以在go代码中切片比数组更常用
二、切片的声明方式
package main
import "fmt"
func main(){
var slice []string
// make(类型，长度，容量。。。)
slice = make([]string,3) // make 内存创建，只用于 切片，map,chan类型
slice[0] = "j"
slice[1] = "m"
slice[2] = "z"
fmt.Println(slice)
}
1、引用类型 可以理解为指针，声明引用类型并不会并不会分配内存。
2、与值类型不同，值类型的变量在声明时会分配内存并存储初始值
3、make 就是用于对引用类型分配内存使用的，并返回类型本身
4、目前make函数只用于 切片，map和chan
三、切片的增删改查
package main
import "fmt"
func main(){
var slice []string
// make(类型，长度，容量。。。)
slice = make([]string,0) // make 内存创建，只用于 切片，map,chan类型
// 增
slice = append(slice,"j")
slice = append(slice,"m","z")
arr := []string{"j","l","y"} // 简短声明切片
slice = append(slice, arr...) // 将切片打撒
fmt.Println(slice) // [j m z j l y]
// 改
// 重新赋值即为改
slice[0] = "j1"
slice[1] = "m2"
slice[2] = "z3"
fmt.Println(slice) // [j1 m2 z3 j l y]
// 查
fmt.Println(slice[3]) // j
fmt.Println(slice[2:4]) // 输入下标2～4直接的数据，包头不包尾，不包含下标4 // [z3 j]
fmt.Println(slice[3:]) // 输出下标3之后的所有数据，包含下标3 // [j l y]
fmt.Println(slice[:3]) // 输出 下标3之前的所有数据，不包含下标3 // [j1 m2 z3]
for index,v := range slice{
fmt.Printf("slice[%d]=%v\n",index,v)
}
/*
slice[0]=j1
slice[1]=m2
slice[2]=z3
slice[3]=j
slice[4]=l
slice[5]=y
*/
// 删
// go 的切片删除是通过append 来实现的
slice1 := []string{}
// 删除slice[3]的数据
slice1 = append(slice1,slice[:3]...) // 包头不包尾，不包含下标3的
slice1 = append(slice1,slice[4:]...)
fmt.Println(slice1) //[j1 m2 z3 l y]
}
四、切片之函数使用
package main
import "fmt"
func main() {
var slice []int
// make(类型，长度，容量。。。)
slice = make([]int, 3) // make 内存创建，只用于 切片，map,chan类型
fmt.Println(slice) // [0,0,0]
slice = append(slice, 4)
fmt.Println(slice) // [0,0,0,4]
saveSlice(slice)
fmt.Println(slice)
}
func saveSlice(s []int){
s[0] = 111
}
[0 0 0]
[0 0 0 4]
[111 0 0 4]
切片是引用类型，你可以理解为指针
切片在传参的过程不是值拷贝的过程
切片传参实际传的是引用
五、切片之拷贝
package main
import "fmt"
func main() {
s := []int{1,2,3,4}
var s1 []int
s1 = make([]int,len(s))
s1 = s // 将 s 复制给 s1
/*
s1 := s // 与上面是一样的效果
*/
s[0] = 111
fmt.Println(s1)
}
1、切片其实本质还是对数组的引用
2、赋值操作其实还是对引用的拷贝
简单点：s1 只是对s引用的拷贝，不是值的拷贝
package main
import "fmt"
func main() {
s := []int{1,2,3,4}
var s1 []int
s1 = make([]int,len(s))
for index := range s{
s1[index] = s[index]
}
s[0] = 1111
fmt.Println(s1)
}
package main
import "fmt"
func main() {
s := []int{1,2,3,4}
var s1 []int
s1 = make([]int,0)
s1 = append(s1,s...)
s[0] = 111
fmt.Println(s1)
}
六、切片之copy
package main
import "fmt"
func main() {
s := []int{1,2,3,4}
s1 := make([]int,len(s))
copy(s1,s)
s[0] = 111
fmt.Println(s1)
}
输出结果
[1 2 3 4]
七、注意
切片的简短声明方式
s := []int{} // var s []int;s = make([]int,0) 一样的