Go数组教程展示了如何在Golang中使用数组。
数组是单一数据类型元素的集合。数组包含固定数量的元素，并且不能增长或收缩。
数组的元素是通过索引访问的。第一个索引是0。默认情况下，空数组初始化为零值（0、0.0、false或“”）。
len函数返回数组的长度。
$ go version go version go1.18.1 linux/amd64
我们使用Go版本1.18。
去声明数组
var a[n]T
我们声明了一个长度为n且类型为T的数组。
var a[5]int
这里我们声明了一个包含五个整数的数组。
a := [5]int{1, 2, 3, 4, 5}
这是Go数组的简写声明和初始化。
去数组初始化
下面的例子展示了如何在Go中初始化一个数组。
package main
import "fmt"
func main() {
var vals [2]int
fmt.Println(vals)
vals[0] = 1
vals[1] = 2
fmt.Println(vals)
}
在代码示例中，我们声明了一个整数数组；该数组可以包含两个元素。
var vals [2]int fmt.Println(vals)
[2]int是整个类型，包括大小号。开头，数组包含0。
vals[0] = 1 vals[1] = 2 fmt.Println(vals)
我们为数组分配两个值。
$ go run array_init.go [0 0] [1 2]
Go数组字面量
Golang有数组字面量；我们可以在{}括号之间指定数组的元素。
package main
import "fmt"
func main() {
vals := [5]int{1, 2, 3, 4, 5}
fmt.Println(vals)
vals2 := [5]int{1, 2, 3}
fmt.Println(vals2)
}
在代码示例中，我们使用数组文字定义了两个数组。
vals := [5]int{1, 2, 3, 4, 5}
第一个数组有五个元素；所有元素都在{}括号之间初始化。
vals2 := [5]int{1, 2, 3}
这里我们只提供五分之三的元素；其余的都初始化为0。
$ go run array_init2.go [1 2 3 4 5] [1 2 3 0 0]
在数组字面量中，我们可以提供元素的索引。
package main
import "fmt"
func main() {
vals := [5]int{1: 6, 2: 7, 4: 9}
fmt.Println(vals)
}
在代码示例中，我们使用数组字面量初始化一个数组。这些值被赋予了它们的索引；其余的数组元素被赋予0值。
$ go run array_init3.go [0 6 7 0 9]
去推断数组长度
Go可以在使用数组字面量时推断数组长度。为此，我们使用省略号...运算符。
package main
import "fmt"
func main() {
vals := [...]int{ 1, 2, 3, 4, 5, 6 }
fmt.Println(vals)
}
在代码示例中，我们在数组声明中使用了...。这告诉Go从提供的数组文字中推断数组的长度。
$ go run infer_length.go [1 2 3 4 5 6]
为了在Go中提取类型信息，我们使用reflect包。
package main
import (
"fmt"
"reflect"
)
func main() {
var a [5]int
var b []int
fmt.Println(reflect.ValueOf(a).Kind())
fmt.Println(reflect.ValueOf(b).Kind())
}
a是数组，b是切片。
$ go run array_slice.go array slice
转到数组长度
数组的长度由len函数决定。
package main
import "fmt"
func main() {
words := [5]string{ "falcon", "sky", "earth", "cloud", "fox" }
fmt.Println("There are", len(words), "words in the array")
}
在代码示例中，我们定义了一个字符串数组。我们打印数组中的单词数。
$ go run array_length.go There are 5 words in the array
去数组索引
数组通过索引访问。
package main
import "fmt"
func main() {
var words[5]string
words[0] = "falcon"
words[1] = "sky"
words[2] = "earth"
words[3] = "cloud"
words[4] = "fox"
fmt.Println(words[0], words[1])
fmt.Println(words)
}
在代码示例中，我们使用一组单词。
var words[5]string
我们声明了一个字符串数组，有五个元素。
words[0] = "falcon" words[1] = "sky" words[2] = "earth" words[3] = "cloud" words[4] = "fox"
我们将五个单词放入数组中。
fmt.Println(words[0], words[1])
我们打印数组的第一个和第二个元素。
fmt.Println(words)
我们打印整个数组。
$ go run indexing.go falcon sky [falcon sky earth cloud fox]
我们可以使用:冒号字符来检索数组的一部分。
package main
import "fmt"
func main() {
words := [...]string{ "falcon", "sky", "earth", "cloud", "fox" }
fmt.Println(words[0:2])
fmt.Println(words[1:])
fmt.Println(words[:])
fmt.Println(words[:len(words)])
}
该示例打印已定义数组的部分内容。
$ go run indexing2.go [falcon sky] [sky earth cloud fox] [falcon sky earth cloud fox] [falcon sky earth cloud fox]
Go数组迭代
使用for循环，我们可以在Go中迭代数组元素。
package main
import "fmt"
func main() {
words := []string{ "falcon", "sky", "earth", "cloud", "fox" }
for i := 0; i < len(words); i++ {
fmt.Println(words[i])
}
for idx, e := range words {
fmt.Println(idx, "=>", e)
}
j := 0
for range words {
fmt.Println(words[j])
j++
}
}
该示例使用三个for循环形式来迭代一个单词数组。
$ go run array_loop.go falcon sky earth cloud fox 0 => falcon 1 => sky 2 => earth 3 => cloud 4 => fox falcon sky earth cloud fox
Go数组是值类型
与其他语言不同，数组在Go中是一种值类型。这意味着当我们将一个数组分配给一个新变量或将一个数组传递给一个函数时，整个数组都会被复制。
package main
import "fmt"
func main() {
vals := [...]int{ 1, 2, 3, 4, 5, 6 }
vals2 := vals
vals2[0] = 11
vals2[1] = 22
fmt.Println(vals)
fmt.Println(vals2)
}
在代码示例中，我们定义了一个数组，并将该数组赋值给一个新变量。通过第二个变量所做的更改不会影响到原始数组。
$ go run value_type.go [1 2 3 4 5 6] [11 22 3 4 5 6]
原数组不变
Go多维数组
我们可以在Go中创建多维数组。我们需要额外的方括号和大括号对来增加数组维度。
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
a := [2][2]int{
{1, 2},
{3, 4}, // the trailing comma is mandatory
}
fmt.Println(a)
var b [2][2]int
rand.Seed(time.Now().UnixNano())
for i := 0; i < 2; i++ {
for j := 0; j < 2; j++ {
b[i][j] = rand.Intn(10)
}
}
fmt.Println(b)
}
我们使用二维整数数组。
a := [2][2]int{
{1, 2},
{3, 4}, // the trailing comma is mandatory
}
fmt.Println(a)
外层数组有两个嵌套数组。
var b [2][2]int
rand.Seed(time.Now().UnixNano())
for i := 0; i < 2; i++ {
for j := 0; j < 2; j++ {
b[i][j] = rand.Intn(10)
}
}
fmt.Println(b)
在第二种情况下，数组被初始化为随机值。我们使用两个for循环。
$ go run two_dim.go [[1 2] [3 4]] [[9 4] [1 3]]
在下面的例子中，我们创建了一个三维数组。
package main
import "fmt"
func main() {
a := [3][2][2]int{
{ {1, 2}, {3, 4} },
{ {5, 6}, {7, 8} },
{ {9, 10}, {11, 12} },
}
fmt.Println(a)
fmt.Println(a[2][1][0])
}
我们需要三对[]和{}括号。
Go数组部分赋值
数组可以部分赋值。
package main
import "fmt"
func main() {
var a [5]int = [5]int{10, 20, 30}
fmt.Println(a)
}
数组的类型和大小必须匹配。没有值的元素将被初始化为零。
$ go run partial_assignment.go [10 20 30 0 0]
最后两个元素初始化为0。
在本教程中，我们使用了Golang中的数组。
列出所有Go教程。
