Go指南-数组与切片

在Golang中,数组与切片是两个概念,数组用的比较少,切片用的比较多,也更为常见,理解了它们之间的关系,能够帮助我们减少一些奇奇怪怪的问题。

一切还要从这张图讲起..

这张图中说明了数组和切片的核心区别,同时也是本文讲解的重点:

1.数组的声明需要指定长度,而切片可指定也可不指定。

2.切片本质是对数组一个引用,切片改变,数组也会改变。

3.切片包含三个部分:数组引用、长度属性、容量属性。长度属性指的是切片的元素数量,决定了可读取数据的上限;而容量属性指的切片的最大元素数量,决定切片了扩展的上限。

1.数组和切片的声明

// 数组的声明
var arr [3]int
arr[0] = 1


// 切片的声明,通过var关键字
var slic []int

// 切片的声明,通过make关键字
slic := make([]int, 0, 0)

复制代码

2.切片是对数组的引用

func main() {
	// 底层数组声明
	names := [4]string{
		"John",
		"Paul",
		"George",
		"Ringo",
	}
	fmt.Println(names)
	
	// 获取切片,a,b共享一个数组
	a := names[0:2]
	b := names[1:3]
	fmt.Println(a, b)
	
	// 改变切片b,会改变底层数组,所以a也变了
	b[0] = "XXX"
	fmt.Println(a, b)
	fmt.Println(names)
}

复制代码

3.切片的长度与容量

切片长度属性指的是切片的元素数量,决定了可读取数据的上限;而容量属性指的切片的最大元素数量,决定切片了扩展的上限

长度的计算: 即切片的元素数量,这个比较好理解。

容量的计算: 从切片的第一个元素起,到底层数组的最后一个元素,即为切片的容量。

栗子一:

func sliceLenAndCap() {
	names := [6]string{
		"John",
		"Paul",
		"George",
		"Ringo",
		"Richer",
		"Amy",
	}

	a := names[2:4]
  fmt.Println(a)
  // 切片a包含George和Ringo元素,所以长度为2
  fmt.Println(len(a))  
  // 从切片的第一个元素算起,即George,底层包含的元素是George到Amy,有4个,所以cap为4
	fmt.Println(cap(a))  
}
复制代码

长度和容量在声明切片时的作用,栗子二:

// 声明了一个长度和容量都为0的切片
// 与 num1 := []int{} 等价
var num1 []int

// 声明了一个长度为0,容量为3的切片,其底层数组包含三个元素,值都是0
num1 := make([]int, 0, 3)

// 声明一个长度为1,容量为3的切片,可以看到其元素值是0
num2 := make([]int, 1, 3)
fmt.Println(num2)  // [0]
复制代码

切片的容量属性:单凭一个长度属性,Go编译器无法知道是否需要对底层数组进行扩容,所以还需要一个容量属性辅助判断。

栗子三:

func sliceAddElem() {
  // 一开始容量为2,即底层数组只有两个元素
	num1 := make([]int, 0, 2)
	fmt.Printf("num1 %p", num1)  //  0xc000020090

  // 添加元素时,发现添加的元素数量超过底层数组的长度,所以创建了一个新的数组,并修改切片的引用,让它指向新数组
	num1 = append(num1, 1, 2, 3, 4)  // 0xc000018140
	fmt.Printf("num1 %p", num1)
}
复制代码

4.切片和数组的注意事项

4.1 切片再强调

  • 切片是对数组的引用,所以它本身并不会存储元素
  • append等方法针对的对象是切片,不是数组,需小心

4.2 Golang数组和C语言数组的区别

1.C语言的数组名是一个元素的地址,代表指针型常量,所以不能将一个数组赋值给另一个数组;而Go的数组是一个值,所以可以赋给另外一个数组,且赋值时是拷贝所有元素到新数组中。

func arrayCopy() {
	arr1 := [3]int{1, 2, 3}
	arr2 := arr1
	fmt.Println(arr2)  // [1 2 3]
	arr1[0] = -1
	fmt.Println(arr1)  // [-1 2 3]
	fmt.Println(arr2)  // [1 2 3]
}

复制代码

2.在Golang中,如果将一个数组传入某个函数,在函数内部接收到的是数组的副本而非指针。如果想传入指针,有两种做法,一是显式加上指针,第二就是传递切片(推荐做法)

func elemAdd(arr [3]int) {
	for idx, _ := range arr{
		arr[idx] += 1
	}
	fmt.Println("new", arr) // [2, 3, 4]
}

func elemAddTest() {
	num1 := [3]int{1, 2, 3}
	elemAdd(num1)
	fmt.Println(num1) // [1, 2, 3]
}

// 1.显式加上指针
func elemAddByPoint(arr *[3]int) {
	for idx, _ := range arr{
		arr[idx] += 1
	}
	fmt.Println("new", arr) // &[2, 3, 4]
}

func elemAddByPointTest() {
	num1 := [3]int{1, 2, 3}
	elemAddByPoint(&num1)
	fmt.Println(num1) // [2, 3, 4]
}

// 2.传递切片
func elemAddBySlice(arr []int) {
	for idx, _ := range arr{
		arr[idx] += 1
	}
	fmt.Println("new", arr) // [2, 3, 4]
}

func elemAddBySliceTest() {
	num1 := []int{1, 2, 3}
	elemAddBySlice(num1)
	fmt.Println(num1) // [2, 3, 4]
}

复制代码

4.3 之前遇到的一个小坑

func sliceTest() {
	// 声明两个切片,一开始两个切片的地址是不一样的
	var t = make([]int, 0, 10)
	var s = make([]int, 0, 10)

	fmt.Printf("addr:%p \tlen:%v content:%v\n", t, len(t), t);  // addr:0xc00009a000       len:0 content:[]
	fmt.Printf("addr:%p \tlen:%v content:%v\n", s, len(s), s);  // addr:0xc00009a050       len:0 content:[]

	t = append(s, 1, 2, 3, 4)

	// 后面t和s的地址是一样的,但是指向的值却不一样
	fmt.Printf("addr:%p \tlen:%v content:%v\n", t, len(t), t); // addr:0xc00009a050       len:4 content:[1 2 3 4]
	fmt.Printf("addr:%p \tlen:%v content:%v\n", s, len(s), s); // addr:0xc00009a050       len:0 content:[]
}
复制代码

这是因为 t = append(s, 1, 2, 3, 4) 这条语句向切片s的底层数组增加了四个元素(仅仅是底层数组变了),并让t指向这个底层数组,所以t和s的地址一样。而且由于新切片被赋值给t,而不是s,所以t的内容是 [1, 2, 3, 4] ,s的内容是 []

我来评几句
登录后评论

已发表评论数()

相关站点

热门文章