标签：package var cap 超过 返回 string 长度 不包含 app
切片Slice在go语言中是单独的类型（指向底层的数组），不同于python(对可迭代对象操作的工具)，注意区分数组和slice的区别
var s []int,这种既没有长度也没有元素赋值的类型（相比叫array）数组的基本操作如下 ，类似与python中列表切片的操作，详见实例
package main
import "fmt"
func main() {
var s1 []int //这样就是一个slice类型，既没有长度也没有元素赋值
a := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} //这是一个数组
s2 := a[5:10] //切片，索引5到10的元素，不包含索引为10
s3 := a[:3] //切片，索引1-3的元素，不包含索引3
s4 := a[6:] //切片，第6个索引到最后一个索引的元素
s5 := a[:] //切片，复制一个数组
fmt.Println(s1)
fmt.Println(a)
fmt.Println(s2) //数组的切片，类似python
fmt.Println(s3)
fmt.Println(s4)
fmt.Println(s5)
}
/*输出
s1---> []
a---> [0 0 0 0 0 0 0 0 0 0]
s2---> [6 7 8 9 10]
s3---> [1 2 3]
s4---> [7 8 9 10]
s5---> [1 2 3 4 5 6 7 8 9 10]
*/使用make初始化一个slice类型，包含三个参数
③容量 cap
package main
import "fmt"
func main() {
s1 := make([]int, 3, 10) //使用make初始化一个slice,包含三个参数：①切片类型②初始长度③容量
fmt.Println(len(s1), cap(s1)) //输出长度，容量
fmt.Println(s1)
}
/*输出：
len(s1)--->3
cap(s1)--->10
s1---> [0 0 0] //可变数组
*/Reslice ,在原slice基础上再次切片，slice一个数组时，不仅取出了len,同时容量也会得到相应的切片。
示例
//Reslice,在slice基础上再次slice.
package main
import "fmt"
func main() {
a := []byte{‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘, ‘k‘, ‘m‘} //定义一个数组，元素为byte类型
sa := a[3:5] // slice切片，取索引三到五，不包含索引5
sb := sa[1:3]
fmt.Println(string(sa))
fmt.Println(len(sa), cap(sa))
fmt.Println(string(sb))
fmt.Println(len(sb), cap(sb))
}
/*输出
sting(sa)---> de
len(sa)---> 2
cap(sa)---> 6
string(sb)---> ef
len(sb)---> 2
cap(sb)---> 5
*/Append,类似python中list类型，使用append,从数组尾部追加元素
如果超过追加的slice的容量则将重新分配数组并拷贝原始数据
package main
import "fmt"
func main() {
s1 := make([]int, 3, 8) //初始化slice,长度位3，容量为8
fmt.Printf("%p\n", s1) //输出s1的内存地址
fmt.Println(s1)
s1 = append(s1, 1, 2, 3) //末尾追加三个元素,cap依然为8
fmt.Printf("%p\n", s1) //原来的slice
fmt.Println(s1)
s1 = append(s1, 1, 2, 3, 4) //继续追加元素，超过原s1容量，会重新分配新的内存地址
fmt.Printf("%p\n", s1) //cap容量超过8，为9
fmt.Println(s1)
}
/*
p*s1---> 0xc042070040
s1---> [0 0 0]
p*s1s1--> 0xc042070040
s1---> [0 0 0 1 2 3]
p*s1---> 0xc04205e080 //新的内存地址
s1---> [0 0 0 1 2 3 1 2 3 4]
*/当两个slice同时指向某一个数组时，改变某一个slice索引时，另一个slice索引值及原数组的索引也会改变
package main
import "fmt"
func main() {
a := []int{1, 2, 3, 4, 5, 6}
s1 := a[2:5]
s2 := a[1:3]
fmt.Println(s1, s2)
s1[0] = 9
fmt.Println(s1, s2)
fmt.Println(a)
}
/*
s1---> [3 4 5]
s2---> [2 3]
//更改s1的slice索引后，s2的索引也会改
s1---> [9 4 5]
s2---> [2 9]
a---> [1 2 9 4 5 6]
*/copy，格式 copy(s1,s2), 将s2拷贝到s1数组中，当len(s1) > len(s2)时，最终将s2中的索引
替换掉s1的索引，当len(s1)<len(s2)时，s1的索引值全部被对应s2的索引替换
示例
package main
import "fmt"
func main() {
s1 := []int{1, 2, 3, 4, 5}
s2 := []int{6, 7, 8}
copy(s1, s2) //将s2的元素拷贝到s1,s2
fmt.Println(s1)
copy(s2, s1)
fmt.Println(s2)
copy(s1, s2[2:3]) //只拷贝某一切片的索引
fmt.Println(s1)
}
/*输出
s1---> [6 7 8 4 5]
s2---> [1 2 3]
s1---> [8 2 3 4 5]
*/标签：package var cap 超过 返回 string 长度 不包含 app
原文地址：https://www.cnblogs.com/failymao/p/9281873.html
