Go 数组

如果我们在程序中只需要保存一两个数字,直接定义变量 a := 10、b := 20 就足够了。但如果要保存全班 50 名同学的考试成绩,总不能连续定义 50 个变量吧?那样不仅写起来繁琐,管理起来也很麻烦。

为了解决这个问题,Go 语言提供了 “数组(Array)”。数组可以用来按顺序保存一组类型相同、数量固定的数据。你可以把数组想象成一排带有编号的储物柜:每个格子里只能存放同一种类型的物品,而且柜子的总格数在创建时就固定下来了,后面不能再增加或减少。

声明与初始化数组

在 Go 语言中,使用数组一般分为两步:先声明数组,再给数组赋初始值。当然,我们也可以在声明数组的同时直接完成初始化。

语法:

// 只声明
var 数组名 [长度]类型

// 指定长度初始化
数组名 := [长度]类型{元素1, 元素2, ..., 元素n}

// 自动推导长度
数组名 := [...]类型{元素1, 元素2, ..., 元素n}

说明:

在 Go 语言中,中括号 [长度] 要写在元素类型的前面,比如 [3]int 就表示包含 3 个整数的数组。常见的创建方式有以下 3 种:

  • 只声明不赋初始值:使用 var 数组名 [长度]类型 声明数组后,Go 语言会自动把每个元素初始化为对应数据类型的默认零值。比如整数和浮点数默认为 0,布尔值默认为 false,字符串默认为空字符串 ""。
  • 指定长度并赋初始值:在花括号 {} 中填入初始元素,元素之间用英文逗号(,)隔开,且元素个数不能超过指定的长度。如果填入的元素少于数组长度,后面没赋值的位置会自动补上默认零值。
  • 自动推导数组长度:如果我们不想手动去数花括号里有多少个元素,可以在中括号里写三个点 [...],编译器会根据初始元素的实际个数自动算出数组长度。

示例 1:声明数组与默认零值

package main

import "fmt"

func main() {
    var nums [3]int
    var flags [2]bool
    fmt.Println(nums)
    fmt.Println(flags)
}

运行结果如下。

[0 0 0]
[false false]

分析:

在这个例子中,我们声明了长度为 3 的整型数组 nums 和长度为 2 的布尔数组 flags。因为没有赋初始值,nums 里的元素默认都是 0,flags 里的元素默认都是 false。如果是 string 类型的数组,每个元素默认则是空字符串 ""。

需要注意的是,定义数组时中括号里的长度必须在编译阶段就能确定。也就是说,长度只能写正整数或者通过 const 定义的常量,不能把普通变量放进中括号里。

// 正确方式
const n = 3
var a [n]int

// 错误方式
n := 3
var b [n]int

在上面的错误方式中,n := 3 定义的是普通变量,编译时会直接报 invalid array length n(无效的数组长度 n)错误。

示例 2:定义数组并赋初始值

package main

import "fmt"

func main() {
    a := [3]int{10, 20, 30}    // 完整初始化
    b := [5]int{10, 20}        // 部分初始化
    fmt.Println(a)
    fmt.Println(b)
}

运行结果如下。

[10 20 30]
[10 20 0 0 0]

分析:

数组 a 的长度为 3,花括号中正好提供了 3 个整数,每个位置都按顺序填入了对应的值。数组 b 的长度为 5,花括号里只给出了前两个元素的值,后面剩下的 3 个位置就会自动补 0。

在函数内部定义并初始化数组时,对于上面的数组 a 来说,下面 2 种方式是等价的。

// 方式 1(推荐)
a := [3]int{10, 20, 30}

// 方式 2
var a = [3]int{10, 20, 30}

其中,方式 1 使用短变量声明 := 省去了 var 关键字,写起来更加简练,平时写代码时我们更推荐使用方式 1。

示例 3:自动推导数组长度

package main

import "fmt"

func main() {
    names := [...]string{"Jack", "Lucy", "Tony"}
    fmt.Println(names)
}

运行结果如下。

[Jack Lucy Tony]

分析:

在定义 names 时,我们在中括号里写了 [...],编译器看到后面花括号里有 3 个字符串,就会自动将其推算为 [3]string 类型。如果后面需要在代码里获取数组的长度,直接调用内置的 len() 函数即可。

这里小伙伴们要注意,定义数组时中括号里面必须写明具体的长度或者 ...,千万不要把中括号留空。如果写成 []string{"Jack", "Lucy", "Tony"},那定义的就不再是数组,而是后面章节会学到的切片。

提示: 在实际开发中,如果我们一开始就已经确定了数组里的所有初始元素,推荐使用 [...] 让编译器自动统计个数。这样既不用自己去数元素个数,以后增删初始元素时也不用手动修改中括号里的数字。

访问与修改数组元素

数组创建好之后,如果我们想要读取或修改里面某一项的值,可以通过 “数组下标” 来实现,下标在编程中也常称为 “索引”。

在 Go 语言中,数组的下标是从 0 开始编号的(注意从 0 开始)。也就是说,第 1 个元素的下标是 0,第 2 个元素的下标是 1,每个位置与下标的对应关系如下图所示。

Go 数组的存储结构与下标对应关系

语法:

// 读取元素
变量名 := 数组名[下标]

// 修改元素
数组名[下标] = 新值

说明:

如果一个数组的长度为 n,那么它合法的下标范围就是 0 到 n - 1,每个元素的下标永远等于它的位置序号减 1。比如长度为 3 的数组,它的 3 个元素依次是 arr[0]、arr[1] 和 arr[2]。

示例 4:访问与修改数组元素

package main

import "fmt"

func main() {
    nums := [3]int{10, 20, 30}
    fmt.Println(nums[0])    // 获取第 1 个元素
    fmt.Println(nums[2])    // 获取第 3 个元素

    nums[1] = 200           // 修改第 2 个元素
    fmt.Println(nums)
}

运行结果如下。

10
30
[10 200 30]

分析:

nums[0] 表示获取数组 nums 的第 1 项,也就是 10。nums[2] 表示获取第 3 项,也就是 30。接着我们执行 nums[1] = 200,把下标为 1 的第 2 项从原来的 20 修改成了 200。

访问数组时,下标不能超出最大合法范围。对于长度为 3 的数组 nums 来说,最大合法下标是 2。如果我们把下标写死成 nums[3],编译时就会直接报 invalid argument: index 3 out of bounds [0:3](下标 3 超出范围)错误:

fmt.Println(nums[3])

这里小伙伴们可以记住一个细节:如果下标是写死的常量数字(如 nums[3]),越界在编译阶段就会直接报错;如果下标是变量(比如循环里不小心多跑了一轮),编译器没法提前算出来,程序就会在运行期间直接报错崩溃(panic)。

清楚了数组的下标从 0 开始编号之后,我们在初始化数组时,还可以在花括号里通过 “下标: 值” 的形式,只给某几个指定下标的位置赋初始值。下面我们来看一个例子。

示例 5:指定下标初始化

package main

import "fmt"

func main() {
    arr := [5]int{1: 10, 3: 30}
    fmt.Println(arr)
}

运行结果如下。

[0 10 0 30 0]

分析:

arr := [5]int{1: 10, 3: 30} 表示定义一个长度为 5 的整型数组。其中 1: 10 表示把下标为 1(第 2 项)的值设为 10,3: 30 表示把下标为 3(第 4 项)的值设为 30,其余没指定的位置保持默认值 0。

数组的类型与比较

学习 Go 数组时,有一个规则小伙伴们一定要重点记牢:在 Go 语言中,数组的长度属于数组类型的一部分。

这是什么意思呢?简单来说,只有当两个数组的 “元素类型” 和 “数组长度” 都完全相同时,它们才属于同一种类型。下面我们通过一个例子来看看。

示例 6:不同长度的数组类型不同

package main

import "fmt"

func main() {
    var a [3]int
    var b [5]int
    a = b
    fmt.Println(a)
}

运行结果如下。

(报错)cannot use b (variable of type [5]int) as [3]int value in assignment

分析:

可能有些小伙伴会问:“a 和 b 里面装的不都是 int 整数吗?为什么不能把 b 赋值给 a 呢?”

这是因为在 Go 编译器看来,变量 a 的类型是 [3]int,而变量 b 的类型是 [5]int。因为中括号里的长度一个是 3、一个是 5,它们属于两种完全不同的数据类型,编译时就会提示无法把 [5]int 类型的值赋给 [3]int 类型的变量。

反过来,只要两个数组的长度和元素类型都完全相同,我们就可以直接使用 == 或 != 来判断它们是否相等。

示例 7:比较两个数组是否相等

package main

import "fmt"

func main() {
    a := [3]int{10, 20, 30}
    b := [3]int{10, 20, 30}
    c := [3]int{10, 20, 40}
    fmt.Println(a == b)
    fmt.Println(a == c)
}

运行结果如下。

true
false

分析:

使用 == 比较两个同类型数组时,程序会按顺序逐一比对它们相同下标位置上的元素。只有当每一个位置上的元素都相等时,结果才会返回 true;只要有任意一个位置的值不同,结果就会返回 false。

需要注意的是,如果两个数组长度不同(如 [3]int 和 [5]int),因为属于不同类型,直接使用 == 或 != 比较同样会编译报错。

数组的赋值与值拷贝

当两个数组的类型(元素类型与长度)完全相同时,我们还可以直接把一个数组赋值给另一个数组。下面我们来看看赋值之后,修改新数组会不会影响原来的数组。

示例 8:数组的赋值与复制

package main

import "fmt"

func main() {
    a := [3]int{10, 20, 30}
    b := a
    b[0] = 100
    fmt.Println(a)
    fmt.Println(b)
}

运行结果如下。

[10 20 30]
[100 20 30]

分析:

在这个例子中,我们先执行 b := a 把数组 a 赋值给 b,再把 b[0] 改为 100。从运行结果可以看出,原数组 a 依然是 [10 20 30],并没有跟着变化。

这是因为 b := a 会把 a 里的所有元素完整复制一份放到新空间里给 b,两者互不干扰,内存关系如下图所示。

Go 数组赋值时的独立副本复制

Go 数组是值类型

如果大家之前学过其他编程语言,可能会对上面的结果感到意外。在不少语言里,把列表或数组直接赋值给另一个变量时,两个变量通常共用同一份底层数据,修改其中一个就会影响另一个。

而 Go 语言的数组属于 “值类型”,赋值或传参时都会完整复制整个数组。如果一个数组包含成千上万个元素,频繁复制就会带来不小的内存开销。因此在实际开发中,只有明确知道数据个数固定不变时才会使用数组,大多数场景下我们更推荐使用后面章节学习的切片。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号