GoLang之切片底层系列一(切片初始化)_golang 切片初始化

GoLang之切片底层系列一（切片初始化）

注:本文以Windos系统上Go SDK 1.18进行讲解

1.var创建不初始值

func main() {
	var a []int
	if a == nil {
		fmt.Println("yes")//输出：yes
	} else {
		fmt.Println("no")
	}
 fmt.Println(len(a), cap(a)) //0 0

}

1
2
3
4
5
6
7
8
9
10
11

2.var创建不初始值再集体赋值

3.var创建初始化值

func main() {
	var a = []int{1, 2}
	fmt.Println(a, len(a), cap(a)) //[1,2]    2  2
}

1
2
3
4
5

4.var创建初始化值不能再超出容量追加值

5.var创建初始化值再集体赋值

6.make创建规则

7.make指定len创建

8.make指定len创建再集体赋值

9.make指定len创建再集体赋值不能再超出容量追加值

10.make指定len创建再集体赋值能再不超出容量追加值

11.make指定len与cap创建再集体赋值不能再超出容量追加值

12.创建不初始化值再集体赋值

13.创建不初始化值不能再超出容量追加值

14.集体复制必须加[]

15.字符串slice直接输出没有引号

16.slice切割

以下说明切片并不改变原来的元素

对于数组，指向数组的指针，或切片a(注意不能是字符串)支持完整切片表达式：
a[low : high : max]
上面的代码会构造与简单切片表达式a[low: high]相同类型、相同长度和元素的切片。另外，它会将得到的结果切片的容量设置为max-low。
完整切片表达式需要满足的条件是0 <= low <= high <= max <= cap(a)，其他条件和简单切片表达式相同
注意:在完整切片表达式中只有第一个索引值（low）可以省略；它默认为0。

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	s := a[1:3]  // s := a[low:high]
	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))
}
/*
s:[2 3] len(s):2 cap(s):4
*/
1
2
3
4
5
6
7
8

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	t1 := a[1:3:3]
	fmt.Printf("t:%v len(t):%v cap(t):%v\n", t1, len(t1), cap(t1)) //t:[2 3] len(t):2 cap(t):2
	t2 := a[1:3:4]
	fmt.Printf("t:%v len(t):%v cap(t):%v\n", t2, len(t2), cap(t2)) //t:[2 3] len(t):2 cap(t):3
	t3 := a[1:3:5]
	fmt.Printf("t:%v len(t):%v cap(t):%v\n", t3, len(t3), cap(t3)) //t:[2 3] len(t):2 cap(t):4
}
1
2
3
4
5
6
7
8
9

func main() {
	a := [5]int{1, 2, 3, 4, 5}
	t1 := a[:3:3]
	fmt.Printf("t:%v len(t):%v cap(t):%v\n", t1, len(t1), cap(t1)) //t:[1 2 3] len(t):3 cap(t):3
	t2 := a[:3:4]
	fmt.Printf("t:%v len(t):%v cap(t):%v\n", t2, len(t2), cap(t2)) //t:[1 2 3] len(t):3 cap(t):4
	t3 := a[:3:5]
	fmt.Printf("t:%v len(t):%v cap(t):%v\n", t3, len(t3), cap(t3)) //t:[1 2 3] len(t):3 cap(t):5
}
1
2
3
4
5
6
7
8
9