Go语言基础之切片

5 切片再切片

除了基于数组得到切片，我们还可以通过切片来得到切片。

func main() {
	//切片再切片
	a := [...]string{"北京", "上海", "广州", "深圳", "成都", "重庆"}
	fmt.Printf("a:%v type:%T len:%d  cap:%d\n", a, a, len(a), cap(a))
	b := a[1:3]
	fmt.Printf("b:%v type:%T len:%d  cap:%d\n", b, b, len(b), cap(b))
	c := b[1:5]
	fmt.Printf("c:%v type:%T len:%d  cap:%d\n", c, c, len(c), cap(c))
}
复制

1
2
3
4
5
6
7
8
9

#输出

a:[北京 上海 广州 深圳 成都 重庆] type:[6]string len:6  cap:6
b:[上海 广州] type:[]string len:2  cap:5
c:[广州 深圳 成都 重庆] type:[]string len:4  cap:4
复制

1
2
3

注意

对切片进行再切片时，索引不能超过原数组的长度，否则会出现索引越界的错误。

#6 使用make()构造切片

我们上面都是基于数组来创建的切片,如果需要动态的创建一个切片,我们就需要使用内置的make()函数，

格式如下

make([]T, size, cap)

T:切片的元素类型
size:切片中元素的数量
cap:切片的容量

#举例如下

func main() {
	a := make([]int, 2, 10)
	fmt.Println(a)      //[0 0]
	fmt.Println(len(a)) //2
	fmt.Println(cap(a)) //10
}
复制

1
2
3
4
5
6

上面代码中a的内部存储空间已经分配了10个，但实际上只用了2个。容量并不会影响当前元素的个数，所以len(a)返回2，cap(a)则返回该切片的容量。

#make初始化和普通声明切片的区别

    //用make初始化切片,并赋值初始值
	s1:=make([]int,5,10)
	fmt.Println(s1) //[0 0 0 0 0]
	//声明切片 但是没有初始化赋值
	var s2 []int
	fmt.Println(s2==nil,s1==nil)//true false
	fmt.Println(len(s1),len(s2)) //5 0
复制

1
2
3
4
5
6
7

#7 切片的本质

切片本质

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。举个例子，现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片s1 := a[:5]，相应示意图如下。

#切片s2 := a[3:6]，相应示意图如下：

#切片不能直接比较

切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素。切片唯一合法的比较操作是和nil比较。一个nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是0。但是我们不能说一个长度和容量都是0的切片一定是nil，例如下面的示例：

var s1 []int         //len(s1)=0;cap(s1)=0;s1==nil
s2 := []int{}        //len(s2)=0;cap(s2)=0;s2!=nil
s3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil
复制