Go语言复合类型之数组详解 - 深度编程教程

介绍

数组是一个固定长度的、特定类型的元素，组成的序列。

数组类型两部分组成：

1. 一是长度，必须是常量，因为数组的长度需要在编译的阶段确定，可以为 0，一旦定义，不能变，可以通过 len 函数返回数组的长度；
2. 二是类型。

需要注意的是：只要长度或者类型有其中一个不一样，就是不同的类型数组，例如：

1. [5]int 和 [10]int 是不同的类型
2. [5]int 和 [5]string 是不同的类型

声明语法如下：

var 数组变量名 [元素数量]T

数组在声明之后会初始化其类型的零值，这个特性是数组和切片以及 map 的重要区别，切片和 map 声明之后默认是 nil，make 之后默认也没有初始值，如下所示：

func main() {
    var a [5]int // 定义完就有初始值
    fmt.Println(a) // [0 0 0 0 0]
}

还有就是由于数组的长度是固定的，所以在实际使用的过程中，用的不是很多。用的比较多是 slice 和 map，他们的长度可以变化。

如何获取数组的长度呢？

可以使用 len 函数获取

var a [3]int
fmt.Println(len(a)) // 3

如何访问数组的元素呢？

可以通过下标进行访问，需要注意的是索引是从 0 到数组长度减 1。不过越过范围

var a [3]int
fmt.Println(a[0]) // 0

如何去遍历数组呢？

可以使用 for range 方便的遍历

var a [3]int
for i, v := range a {
 fmt.Println(i, v)
}

初始化

默认情况下，数组每个元素，都被初始化成元素类型对应的零值，我们可以使用 数组字面值语法 用一组值来初始化数组：

var cityList [3]string = [3]string{"北京", "上海", "广州"}

可以省略声明类型，自动推导：

var cityList = [3]string{"北京", "上海", "广州"}

可以不指定数组的长度，由元素数量自动确定

var cityList = [...]string{"北京", "上海", "广州"}

可以设置数组的key，不过好像只能是数值，不能是字符串：

type currency int // 货币
const (
   USD currency = iota
 EUR
 GBP
 RMB
)
func main() {
   label := [...]string{USD: "美元", EUR: "欧元", GBP: "英镑", RMB: "人民币"}
   fmt.Println(label)
}

在这种形式的数组字面值形式中，初始化索引的顺序是无关紧要的，而且没用到的索引可以省略，和前面提到的规则一样，未指定初始值的元素将用零值初始化。例如，

r := [...]int{99: -1}

定义了一个含有 100 个元素的数组 r，最后一个元素被初始化为-1，其它元素都是用 0 初始化。

访问数组中的元素

可以通过 索引下标 进行访问和设置，下标是从 0 开始，到数组长度减1的位置：

var cityList = [...]string{0: "北京", 1: "上海", 2: "广州"}
fmt.Println(cityList[0])

访问越界，如下因为最长的值2，访问3就会出错

var cityList = [...]string{0: "北京", 1: "上海", 2: "广州"}
fmt.Println(cityList[3])

多维数组的声明

基本和一维度数组是一样的，只是在一维数组签名再加个行数[行数]

var cityList = [3][1]string{
    {"北京"},
   {"上海"},
   {"广州"}, // 必须是豆号结尾，如果不逗号结尾外层花括号不能换行
}
fmt.Println(cityList[2][0]) // 可以访问某个元素

[3] 代表是 3 行，[1]{string} 代表每行里的一维数组格式，这个和普通的以为数组定义是一样的。

多维数组行数可以使用 ... 来让编译器推导数组行数：

var cityList = [...][1]string{
  {"北京"},
   {"上海"},
   {"广州"}, // 必须是豆号结尾，如果不逗号结尾外层花括号不能换行
}

比较

如果一个数组的元素类型是可以相互比较的，那么数组类型也是可以相互比较的，这时候我 们可以直接通过==比较运算符来比较两个数组，只有当两个数组的所有元素都是相等的时候 数组才是相等的。不相等比较运算符!=遵循同样的规则。

func main() {
   a := [2]int{1, 2}
   b := [...]int{1, 2}
 c := [...]int{1, 3}
 fmt.Println(a == b, b == c, c == a) // true false false

 d := [3]int{1, 2}
   fmt.Println(a == d) // invalid operation: a == d (mismatched types [2]int and [3]int)
}