今天聊聊GO中的数组以及切片

数组

数组的定义

数组是具有相同类型且长度固定的一组连续数据。在go语言中我们可以使用如下几种方式来定义数组。

//方式一
var arr1 = [5]int{}
//方式二
var arr2 = [5]int{1,2,3,4,5}
//方式三
var arr3 = [5]int{3:10}

//arr1 [0 0 0 0 0]
//arr2 [1 2 3 4 5]
//arr3 [0 0 0 10 0]

1. 方法一在声明时没有为其指定初值，所以数组内的值被初始化为类型的零值。
2. 方法二使用显示的方式为数组定义初值。
3. 方法三通过下标的方式为下标为3的位置赋上了初值10。

赋值操作

for i := 0; i < len(arr1); i++ {
		arr1[i] = i * 10
	}

数组遍历

for index, value := range arr1 {
	fmt.Printf("index: %d, value: %d\n", index, value)
}

多维数组

与其他语言一样，go语言也可以定义多维数组，可以选择的定义方式如下：

var arr4 = [5][5]int{
	{1, 2, 3, 4, 5},
	{6, 7, 8, 9, 10},
}
//[[1 2 3 4 5] [6 7 8 9 10] [0 0 0 0 0] [0 0 0 0 0] [0 0 0 0 0]]

指针数组

对于指针数组来说，就是：一个数组里面装的都是指针，在go语言中数组默认是值传递的，所以如果我们在函数中修改传递过来的数组对原来的数组是没有影响的。

func main() {
	var a [5]int
	fmt.Println(a)
	test(a)
	fmt.Println(a)
}

func test(a [5]int) {
	a[1] = 2
	fmt.Println(a)
}

/*
[0 0 0 0 0]
[0 2 0 0 0]
[0 0 0 0 0]
*/

数组指针

数组指针也叫指向数组的指针。

func main() {
	var a [5]int
	var aPtr *[5]int
	aPtr = &a
	//这样简短定义也可以aPtr := &a
	fmt.Println(aPtr)
	test(aPtr)
	fmt.Println(aPtr)
}


func test(aPtr *[5]int) {
	aPtr[1] = 5
	fmt.Println(aPtr)
}

/*
&[0 0 0 0 0]
&[0 5 0 0 0]
&[0 5 0 0 0]
*/

通过上面的图我们可以看见虽然main和test函数中的aPtr是不同的指针，但是他们都指向同一块数组的内存空间，所以无论在main函数还是在test函数中对数组的操作都会直接改变数组。

切片

因为数组是固定长度的，所以修改起来就不够灵活，因此GO语言就提供了一种便捷的数据类型叫做切片。切片操作与数组类似，只是它的长度不是固定的，可以追加元素，如果达到了当前切片容量的上限，那么就会自动扩容。

//方法一
var s1 = []int{}
//方法二
var s2 = []int{1, 2, 3}
//方法三
var s3 = make([]int, 5)
//方法四
var s4 = make([]int, 5, 10)

/*
s1 [] 0 0
s2 [1 2 3] 3 3
s3 [0 0 0 0 0] 5 5
s4 [0 0 0 0 0] 5 10
*/

获取长度

我们可以用过len(),cap()这两个函数来获取切片的长度以及容量。

func main() {
	arr := [5]int{1, 2, 3, 4, 5}
	s := []int{6, 7, 8, 9, 10}

	s1 := arr[2:4]
	s2 := arr[:3]
	s3 := arr[2:]
	s4 := s[1:3]

	fmt.Println("s1:", s1)
	fmt.Println("s2:", s2)
	fmt.Println("s3:", s3)
	fmt.Println("s4:", s4)
}

/*
s1: [3 4]
s2: [1 2 3]
s3: [3 4 5]
s4: [7 8]
*/

可以看到，上面操作的数值范围是左闭右开的。

扩充

func main() {
	a := []int{1, 2, 3}
	b := a[1:3]

	b = append(b, 4)
	b = append(b, 5)
	b = append(b, 6)
	b = append(b, 7)
	fmt.Println(a)
	fmt.Println(b)
}

拼接

func main() {
	a := []int{1, 2, 3}
	b := a[1:3]

	fmt.Println(b)

	a = append(a, b...)
	fmt.Println(a)
}

赋值

func main() {
	a := []int{1, 2, 3}
	b := make([]int, 3)
	copy(b, a)
	fmt.Println(a)
	fmt.Println(b)
}