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

数组声明

数组属于类型 [n]Tn 表示数组中元素的数量,T 表示每个元素的类型。 元素的数量 n 也是类型的一部分(我们将在稍后更详细地讨论这一点。)

声明数组有不同的方法。 让我们一一看看它们。

1
2
3
4
5
6
7
8
9
10
package main

import (
"fmt"
)

func main() {
var a [3]int // 长度为 3 的数组
fmt.Println(a)
}

Run in playground

var a[3]int 声明了一个长度为 3 的整数数组。数组中的所有元素都会自动分配数组类型的零值。 在这种情况下,a 是一个整数数组,因此 a 的所有元素都分配给 0,即 int 的零值。 运行上面的程序会打印

1
[0 0 0]

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package main

import (
"fmt"
)


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

Run in playground

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

1
[12 78 50]

让我们使用 短声明 来创建相同的数组。

1
2
3
4
5
6
7
8
9
10
package main

import (
"fmt"
)

func main() {
a := [3]int{12, 78, 50} // 创建数组的短声明
fmt.Println(a)
}

Run in playground

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

1
[12 78 50]

使用短声明时,不必为数组中的所有元素分配一个值。

1
2
3
4
5
6
7
8
9
10
package main

import (
"fmt"
)

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

Run in playground

在上面的程序中,a := [3]int{12} 声明了一个长度为 3 的数组,但只提供了一个值 12。 其余 2 个元素自动分配为 0。 该程序将打印

1
[12 0 0]

你甚至可以忽略声明中数组的长度,并用 ... 替换它,让编译器自动计算长度。 代码实现如下。

1
2
3
4
5
6
7
8
9
10
package main

import (
"fmt"
)

func main() {
a := [...]int{12, 78, 50} // ... 让编译器决定数组长度
fmt.Println(a)
}

Run in playground

数组的大小是类型的一部分。 因此 [5]int[25]int 是不同的类型。 因此,无法调整数组大小。 不要担心这个限制,因为可以使用 切片 来突破这个限制。

1
2
3
4
5
6
7
package main

func main() {
a := [3]int{5, 78, 8}
var b [5]int
b = a // 不可能成立,因为 `[3]int` 和 `[5]int` 是不同的类型
}

Run in playground

在上面的程序中,我们试图将类型为 [3]int 的变量分配给类型为 [5]int 的变量,这是不允许的,因此编译器将打印以下错误

1
./prog.go:6:7: cannot use a (type [3]int) as type [5]int in assignment

数组是值类型

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

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

func main() {
a := [...]string{"USA", "China", "India", "Germany", "France"}
b := a // a 的副本被分配给 b
b[0] = "Singapore" // b 的第一个元素被改变为 Singapore,这不会影响到 a
fmt.Println("a is ", a)
fmt.Println("b is ", b)
}

Run in playground

程序会打印出:

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

同样,当数组作为参数传递给函数时,它们是按值传递的,原始数组不变。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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 是按值传递的,因此不会因为函数调用而改变
fmt.Println("after passing to function ", num)
}

Run in playground

该程序将打印:

1
2
3
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 函数来得到的。

1
2
3
4
5
6
7
8
package main

import "fmt"

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

Run in playground

上面的程序会打印出

1
length of a is 4

使用 range 迭代数组

for 循环可用于迭代数组的元素。

1
2
3
4
5
6
7
8
9
10
package main

import "fmt"

func main() {
a := [...]float64{67.7, 89.8, 21, 78}
for i := 0; i < len(a); i++ { // 从 0 循环到数组的长度
fmt.Printf("%d th element of a is %.2f\n", i, a[i])
}
}

Run in playground

上面的程序使用一个 for 循环来迭代数组的元素,从索引 0length of the array - 1。 这个程序可以工作并且会打印

1
2
3
4
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 返回索引和该索引处的值。 让我们使用 range 重写上面的代码。 我们还将找到数组所有元素的总和。

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func main() {
a := [...]float64{67.7, 89.8, 21, 78}
sum := float64(0)
for i, v := range a { // range 同时返回索引和值
fmt.Printf("%d the element of a is %.2f\n", i, v)
sum += v
}
fmt.Println("\nsum of all elements of a",sum)
}

Run in playground

我们打印值并计算数组 a 的所有元素的总和。 程序的输出是,

1
2
3
4
5
6
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

如果你只想要该值而想要忽略索引,您可以通过用 _ 空白标识符替换索引来实现。

1
2
for _, v := range a { // 忽略索引
}

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

多维数组

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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"}, // 这个逗号是必须的。 如果省略这个逗号,编译器会报错
}
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)
}

Run in playground

上面的程序会打印:

1
2
3
4
5
6
7
lion tiger
cat dog
pigeon peacock

apple samsung
microsoft google
AT&T T-Mobile

这就是数组。 尽管数组似乎足够灵活,但它们具有固定长度的限制。 无法增加数组的长度。而这正是 切片 擅长的。 事实上,在 Go 中,切片比传统数组更常见。

结语

关注公众号紫升早茶馆,一个持续分享编程知识的地方。

  • 点赞等于学会,在看等于精通
  • 最后祝大家 2021 学习进步,升职加薪

紫升

原文地址 Arrays and Slices
原文作者:Naveen Ramanathan
译文出自:紫升翻译计划