一文搞懂 Golang 中的数组和切片

数组

数组是属于同一类型的元素的集合。例如，整数 5、8、9、79、76 的集合形成一个数组。Go 中不允许混合不同类型的值，例如，同时包含字符串和整数的数组。

声明一个数组

声明数组的语法为 [n]T，这里的 n 表示数组的长度，T 表示这个数组里面存储的元素的数据类型。注意：元素的数量也是类型的一部分。

声明数组的方法有很多种：

package main

import (
	"fmt"
)


func main() {
	var a [3]int // 存储 int 类型数据的数组
	fmt.Println(a)
}

var a [3]int 声明长度为 3 的整数数组。数组中的所有元素都会自动分配数组类型的零值。在本例中是一个整数数组，因此所有元素都分配给 int 的零值。运行上述程序将打印：

[0, 0, 0]

数组的索引从 0 开始到 n-1。让我们为上面的数组分配一些值：

package main

import (
	"fmt"
)


func main() {
	var a [3]int // 长度为 3 的数组，类型为 [3]int
	a[0] = 12 // 数组的下标从 0 开始
	a[1] = 78
	a[2] = 50
	fmt.Println(a)
}

a[0] 将值赋给数组的第一个元素。程序将打印：

[12 78 50]

让我们使用简写声明创建相同的数组：

package main 

import (
	"fmt"
)

func main() {
	a := [3]int{12, 78, 50}
	fmt.Println(a)
}

上面的程序将打印相同的输出：

[12 78 50]

我们也可以通过 a := [3]int{12} 这种方式来声明一个数组，在这种情况下，我们不需要为数组中的所有元素分配一个值：

package main

import (
	"fmt"
)

func main() {
	a := [3]int{12} 
	fmt.Println(a)
}

在上面的程序中，第 8 行声明了一个长度为 3 的数组，但只提供了一个值。其余 2 个元素是自动分配的。该程序将打印：

[12 0 0]

您甚至可以忽略声明中数组的长度，并将其替换为并让编译器为您找到长度。这是在以下程序中完成的。

package main

import (
	"fmt"
)

func main() {
	a := [...]int{12, 78, 50} // ... 将会被编译器替换为 3，也就是数组实际的长度
	fmt.Println(a)
}

数组的大小是类型的一部分。因此，[5]int 和 [25]int 是不同的类型。因此，无法调整数组的大小。不要担心这个限制，因为 slices 可以实现这种需求。

package main

func main() {
	a := [3]int{5, 78, 8}
	var b [5]int
	b = a // 错误：因为 [3]int 和 [5]int 是不同的数据类型
}

数组是值类型

Go 中的数组是值类型，而不是引用类型。这意味着，当它们被分配给新变量时，原始数组的副本将分配给新变量。如果对新变量进行了更改，则它不会反映在原始数组中。

package main

import "fmt"

func main() {
	a := [...]string{"USA", "China", "India", "Germany", "France"}
	b := a // a copy of a is assigned to b
	b[0] = "Singapore"
	fmt.Println("a is ", a)
	fmt.Println("b is ", b)	
}

在上面程序的第 7 行中，将 a 的副本分配给 b 。在第 8 行中，第一个 b 元素更改为 Singapore 。这不会反映在原始数组 a 中。程序将打印，

a is [USA China India Germany France]
b is [Singapore China India Germany France]

同样，当数组作为参数传递给函数时，它们按值传递，原始数组保持不变。

package main

import "fmt"

func changeLocal(num [5]int) {
	num[0] = 55
	fmt.Println("inside function ", num)

}
func main() {
	num := [...]int{5, 6, 7, 8, 8}
	fmt.Println("before passing to function ", num)
	changeLocal(num) //num is passed by value
	fmt.Println("after passing to function ", num)
}

在上面的第 13 行程序中，数组 num 实际上是按值传递给函数的，因此不会因为函数 changeLocal 调用而改变。该程序将打印，

before passing to function  [5 6 7 8 8]
inside function  [55 6 7 8 8]
after passing to function  [5 6 7 8 8]

数组的长度

数组的长度是通过将数组作为参数传递给 len 函数来找到的。

package main

import "fmt"

func main() {
	a := [...]float64{67.7, 89.8, 21, 78}
	fmt.Println("length of a is",len(a))
	
}

上述程序的输出是

length of a is 4

使用 range 迭代数组

for 循环可用于遍历数组的元素。

package main

import "fmt"

func main() {
	a := [...]float64{67.7, 89.8, 21, 78}
	for i := 0; i < len(a); i++ { //looping from 0 to the length of the array
		fmt.Printf("%d th element of a is %.2f\n", i, a[i])
	}
}

上面的程序使用一个 for 循环来遍历数组的元素，从下标 0 到 数组长度 - 1 .该程序有效并将打印，

0 th element of a is 67.70
1 th element of a is 89.80
2 th element of a is 21.00
3 th element of a is 78.00

Go 提供了一种更好、更简洁的方法，通过使用 for 循环的范围形式来迭代数组。 range 返回索引和该索引处的值。让我们使用 range 重写上面的代码。我们还将找到数组中所有元素的总和。

package main

import "fmt"

func main() {
	a := [...]float64{67.7, 89.8, 21, 78}
	sum := float64(0)
	for i, v := range a {//range returns both the index and value
		fmt.Printf("%d the element of a is %.2f\n", i, v)
		sum += v
	}
	fmt.Println("\nsum of all elements of a",sum)
}

上述程序 for i, v := range a 的第 8 行是 for 循环的范围形式。它将返回索引和该索引处的值。我们打印值并计算数组 a 中所有元素的总和。该程序的输出是，

0 the element of a is 67.70
1 the element of a is 89.80
2 the element of a is 21.00
3 the element of a is 78.00

sum of all elements of a 256.5

如果只需要该值并忽略索引，则可以通过将索引替换为 _ 空白标识符来执行此操作。

for _, v := range a { //ignores index
}

面的 for 循环忽略了索引。同样，也可以忽略该值。

多维数组

到目前为止，我们创建的数组都是单维的。可以创建多维数组。

package main

import (
	"fmt"
)

func printarray(a [3][2]string) {
	for _, v1 := range a {
		for _, v2 := range v1 {
			fmt.Printf("%s ", v2)
		}
		fmt.Printf("\n")
	}
}

func main() {
	a := [3][2]string{
		{"lion", "tiger"},
		{"cat", "dog"},
		{"pigeon", "peacock"}, //this comma is necessary. The compiler will complain if you omit this comma
	}
	printarray(a)
	var b [3][2]string
	b[0][0] = "apple"
	b[0][1] = "samsung"
	b[1][0] = "microsoft"
	b[1][1] = "google"
	b[2][0] = "AT&T"
	b[2][1] = "T-Mobile"
	fmt.Printf("\n")
	printarray(b)
}

在上面的第 17 行程序中，使用简写语法声明了一个二维字符串数组 a 。第 20 行末尾的逗号是必需的。这是因为词法分析器会根据简单的规则自动插入分号。如果您有兴趣了解更多关于为什么需要分号的信息，请阅读 https://golang.org/doc/effective_go.html#semicolons

在第 23 行中声明另一个二维数组 b ，并为每个索引逐个添加字符串。这是初始化二维数组的另一种方法。

第 7 行中的 printarray 函数使用两个 for 范围循环来打印二维数组的内容。上面的程序将打印

lion tiger 
cat dog 
pigeon peacock 

apple samsung 
microsoft google 
AT&T T-Mobile 

这就是数组。尽管数组看起来足够灵活，但它们有一个限制，即它们的长度是固定的。无法增加数组的长度。这就是切片的用武之地。事实上，在 Go 中，切片比传统数组更常见。

切片

切片的底层是一个数组，切片本身不拥有任何数据，它们只是对现有数组的引用。

创建切片

具有 T 类型元素的切片表示为 []T

package main

import (
	"fmt"
)

func main() {
	a := [5]int{76, 77, 78, 79, 80}
	var b []int = a[1:4] //creates a slice from a[1] to a[3]
	fmt.Println(b)
}

a[start:end] 语法从数组 a 创建一个从索引到索引 start 到 end - 1 的切片。因此，在上面程序 a[1:4] 的第 9 行中，从索引 1 到 3 开始创建数组 a 的切片表示。因此，切片 b 具有值 [77 78 79] 。

让我们看看创建切片的另一种方法。

package main

import (
	"fmt"
)

func main() {
	c := []int{6, 7, 8} //creates and array and returns a slice reference
	fmt.Println(c)
}

在上面的程序第 9 行中， c := []int{6, 7, 8} 创建一个具有 3 个整数的数组并返回了一个切片引用。

修改切片

切片不拥有自己的任何数据。它只是基础数组的表示形式。对切片所做的任何修改都将反映在基础数组中。

package main

import (  
    "fmt"
)

func main() {  
    darr := [...]int{57, 89, 90, 82, 100, 78, 67, 69, 59}
    dslice := darr[2:5]
    fmt.Println("array before",darr)
    for i := range dslice {
        dslice[i]++
    }
    fmt.Println("array after",darr) 
}

在上面程序的第 9 行中，我们从数组的索引 2、3、4 创建 dslice 。for 循环将这些索引中的值递增 1。当我们在 for 循环之后打印数组时，我们可以看到对切片的更改反映在数组中。程序的输出是

array before [57 89 90 82 100 78 67 69 59]
array after [57 89 91 83 101 78 67 69 59]

当多个切片共享相同的基础数组时，每个切片所做的更改将反映在数组中。

package main

import (
	"fmt"
)

func main() {
	numa := [3]int{78, 79 ,80}
	nums1 := numa[:] //creates a slice which contains all elements of the array
	nums2 := numa[:]
	fmt.Println("array before change 1",numa)
	nums1[0] = 100
	fmt.Println("array after modification to slice nums1", numa)
	nums2[1] = 101
	fmt.Println("array after modification to slice nums2", numa)
}

在第 9 行中， numa[:] 缺少开始值和结束值。start 和 end 的默认值分别为 0 和 len(numa) 。两个切片 nums1 和 nums2 共享同一个数组。程序的输出是

array before change 1 [78 79 80]
array after modification to slice nums1 [100 79 80]
array after modification to slice nums2 [100 101 80]

从输出中可以清楚地看出，当切片共享相同的数组时。对切片所做的修改将反映在数组中。

切片的长度和容量

切片的长度是切片中的元素数。切片的容量是基础数组中从创建切片的索引开始的元素数。

让我们编写一些代码来更好地理解这一点。

package main

import (
	"fmt"
)

func main() {
	fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
	fruitslice := fruitarray[1:3]
	fmt.Printf("length of slice %d capacity %d", len(fruitslice), cap(fruitslice)) //length of fruitslice is 2 and capacity is 6
}

在上面的程序中， fruitslice 是从索引 1 和 2 创建的 fruitarray 。因此 的 fruitslice 长度为 2。

fruitarray 的长度为 7。 fruiteslice 是从 fruitarray 的索引 1 创建的。因此，fruitslice 容量是从 fruitarray 索引 1 开始的元素数，即从orange ，该值为 6 。因此，fruitslice 的容量为 6。程序打印 length of slice 2 capacity 6。

切片可以重新切片至其容量。超出此范围的任何内容都会导致程序引发运行时错误。

package main

import (  
    "fmt"
)

func main() {  
    fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
    fruitslice := fruitarray[1:3]
    fmt.Printf("length of slice %d capacity %d\n", len(fruitslice), cap(fruitslice)) //length of is 2 and capacity is 6
    fruitslice = fruitslice[:cap(fruitslice)] //re-slicing furitslice till its capacity
    fmt.Println("After re-slicing length is",len(fruitslice), "and capacity is",cap(fruitslice))
}

在上述程序的第 11 行中， fruitslice 被重新切片到其容量。上述程序输出，

length of slice 2 capacity 6
After re-slicing length is 6 and capacity is 6

使用 make 创建切片

func make([]T, len, cap) []T 可用于通过传递类型、长度和容量来创建切片。capacity 参数是可选的，默认为长度。make 函数创建一个数组并返回对该数组的切片引用。

package main

import (
	"fmt"
)

func main() {
	i := make([]int, 5, 5)
	fmt.Println(i)
}

默认情况下，当使用 make 创建切片时，这些值为零。上面的程序将输出 [0 0 0 0 0] .

追加到切片

正如我们已经知道的，数组被限制为固定长度，并且它们的长度不能增加。切片是动态的，可以使用 append 函数将新元素附加到切片中。append 函数的定义是 func append(s []T, x ...T) []T 。

函数定义中的 x ...T 表示函数接受参数 x 的可变数量的参数。这些类型的函数称为可变参数函数。

不过，有一个问题可能会困扰您。如果切片由数组支持，并且数组本身是固定长度的，那么为什么切片是动态长度的。那么，在后台发生的事情是，当新元素被附加到切片时，就会创建一个新数组。现有数组的元素将复制到此新数组中，并返回此新数组的新切片引用。现在，新切片的容量是旧切片的两倍。很酷，对吧:)。以下程序将把事情弄清楚。

package main

import (
	"fmt"
)

func main() {
	cars := []string{"Ferrari", "Honda", "Ford"}
	fmt.Println("cars:", cars, "has old length", len(cars), "and capacity", cap(cars)) //capacity of cars is 3
	cars = append(cars, "Toyota")
	fmt.Println("cars:", cars, "has new length", len(cars), "and capacity", cap(cars)) //capacity of cars is doubled to 6
}

在上面的程序中，容量 cars 最初是 3。我们将一个新元素附加到第 10 行的汽车中，并再次将返回的 append(cars, "Toyota") 切片分配给汽车。现在汽车的容量翻了一番，变成了 6 辆。上述程序的输出是

cars: [Ferrari Honda Ford] has old length 3 and capacity 3
cars: [Ferrari Honda Ford Toyota] has new length 4 and capacity 6

切片类型的零值为 nil 。 nil 切片的长度和容量为 0。可以使用 append 函数将值追加到 nil 切片中。

package main

import (
	"fmt"
)

func main() {
	var names []string //zero value of a slice is nil
	if names == nil {
		fmt.Println("slice is nil going to append")
		names = append(names, "John", "Sebastian", "Vinay")
		fmt.Println("names contents:",names)
	}
}

在上面的程序 names 中是 nil，我们在 names .程序的输出是

slice is nil going to append
names contents: [John Sebastian Vinay]

也可以使用 ... 运算符将一个切片附加到另一个切片。您可以在可变参数函数教程中了解有关此运算符的更多信息。

package main

import (
	"fmt"
)

func main() {
	veggies := []string{"potatoes","tomatoes","brinjal"}
	fruits := []string{"oranges","apples"}
	food := append(veggies, fruits...)
	fmt.Println("food:",food)
}

在上述程序的第 10 行中，食物是通过附加 fruits 到 veggies .程序的输出是 food: [potatoes tomatoes brinjal oranges apples]

将切片传递给函数

切片可以被认为是由结构类型在内部表示的。这是它的样子，

type slice struct {
    Length        int
    Capacity      int
    ZerothElement *byte
}

切片包含长度、容量和指向数组第 0 个元素的指针。当切片传递给函数时，即使它是按值传递的，指针变量也会引用相同的基础数组。因此，当切片作为参数传递给函数时，函数内部所做的更改在函数外部也可见。让我们编写一个程序来检查这一点。

package main

import (
	"fmt"
)

func subtactOne(numbers []int) {
	for i := range numbers {
		numbers[i] -= 2
	}

}
func main() {
	nos := []int{8, 7, 6}
	fmt.Println("slice before function call", nos)
	subtactOne(nos)                               //function modifies the slice
	fmt.Println("slice after function call", nos) //modifications are visible outside
}

上述程序第 17 行中的函数调用将切片的每个元素递减 2。在函数调用后打印切片时，这些更改是可见的。如果您还记得，这与数组不同，在数组中，对函数内部数组所做的更改在函数外部不可见。上述程序的输出为，

slice before function call [8 7 6]
slice after function call [6 5 4]

多维切片

与数组类似，切片可以具有多个维度。

package main

import (
	"fmt"
)


func main() {
 	pls := [][]string {
			{"C", "C++"},
			{"JavaScript"},
			{"Go", "Rust"},
			}
	for _, v1 := range pls {
		for _, v2 := range v1 {
			fmt.Printf("%s ", v2)
		}
		fmt.Printf("\n")
	}
}

该程序的输出是，

C C++ 
JavaScript 
Go Rust 

内存优化

切片包含对基础数组的引用。只要片在内存中，数组就不能被垃圾回收。当涉及到内存管理时，这可能是一个问题。假设我们有一个非常大的数组，我们只对处理其中的一小部分感兴趣。此后，我们从该数组创建一个切片并开始处理该切片。这里需要注意的重要一点是，数组仍将在内存中，因为切片引用了它。

解决此问题的一种方法是使用 copy 函数创建该切片的副本。这样我们就可以使用新的切片，而原始数组可以被垃圾回收。

package main

import (
	"fmt"
)

func countries() []string { 
    countries := []string{"USA", "Singapore", "Germany", "India", "Australia"}
	neededCountries := countries[:len(countries)-2]
	countriesCpy := make([]string, len(neededCountries))
	copy(countriesCpy, neededCountries) //copies neededCountries to countriesCpy
	return countriesCpy
}
func main() {
	countriesNeeded := countries()
	fmt.Println(countriesNeeded)
}

在上述程序的第 9 行中，创建一个禁止最后 2 个元素的切片。上述程序的第 11 行复制到下一行的函数，并从中返回它。现在数组可以被垃圾回收，因为不再被引用。