数组

• 数组是一种固定长度且有序的元素集合。

访问数组元素

• 数组中的每个元素都可以通过[ ] 和一个从 0 开始的索引进行访问。
• 数组的长度可由内置函数 len 来确定。
• 在声明数组时，未被赋值元素的值是对应类型的零值。

数组越界

• Go 编译器在检测到对越界元素的访问时会报错
• 如果 Go 编译器在编译时未能发现越界错误，那么程序在运行时会出现 panic
• Panic 会导致程序崩溃

使用复合字面值初始化数组

• 复合字面值（composite literal）是一种给复合类型初始化的紧凑语法。
• Go 的复合字面值语法允许我们只用一步就完成数组声明和数组初始化两步操作：

• 可以在复合字面值里使用 … 作为数组的长度，这样 Go 编译器会为你算出数组的元素数量

package main
import "fmt"
func main() {
    planets := [...]string{
        "Mercury",
        "Venus",
        "Earth",
        "Mars",
        "Jupiter",
        "Saturn",
        "Uranus",
        "Neptune",
    }
    fmt.Println(planets)
    fmt.Println(len(planets))
}

• 无论哪种方式，数组的长度都是固定的。

遍历数组

• for 循环

package main
import "fmt"
func main() {
    dwarfs := [5]string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
    for i := 0; i < len(dwarfs); i++ {
        dwarf := dwarfs[i]
        fmt.Println(i, dwarf)
    }
}

• 使用 range

package main
import "fmt"
func main() {
    dwarfs := [5]string{"Ceres", "Pluto", "Haumea", "Makemake", "Eris"}
    for i, dwarf := range dwarfs {
        fmt.Println(i, dwarf)
    }
}

数组的复制

• 无论数组赋值给新的变量还是将它传递给函数，都会产生一个完整的数组副本。

package main
import "fmt"
func main() {
    planets := [...]string{
        "Mercury",
        "Venus",
        "Earth",
        "Mars",
        "Jupiter",
        "Saturn",
        "Uranus",
        "Neptune",
    }
    planetsMarkII := planets
    planets[2] = "whoops"
    fmt.Println(planets)
    fmt.Println(planetsMarkII)
}

• 数组也是一种值，函数通过值传递来接受参数。所以数组作为函数的参数就非常低效。

package main
import "fmt"
// terraform accomplishes nothing
func terraform(planets [8]string) {
    for i := range planets {
        planets[i] = "New " + planets[i]
    }
}
func main() {
    planets := [...]string{
        "Mercury",
        "Venus",
        "Earth",
        "Mars",
        "Jupiter",
        "Saturn",
        "Uranus",
        "Neptune",
    }
    terraform(planets)
    fmt.Println(planets)
}

• 数组的长度也是数组类型的一部分。
• 尝试将长度不符的数组作为参数传递，将会报错。
• 函数一般使用 slice 而不是数组作为参数。

数组的数组

package main
import "fmt"
func main() {
    var board [8][8]string
    board[0][0] = "r"
    board[0][7] = "r"
    for column := range board[1] {
        board[1][column] = "p"
    }
    fmt.Print(board)
}

作业题

• 扩展例子 16.8 的程序，使用字符 kqrbnp 表示上方的黑棋，字符 KQRBNP 表示下方的白棋，然后在棋子的起始位置是打印出所有的棋子。
• 编写一个能够美观的打印出整个棋盘的函数
• 使用 [8][8]rune 数组而不是字符串来表示棋盘。

package main
import "fmt"
func display(board [8][8]rune) {
    for _, row := range board {
        for _, column := range row {
            if column == 0 {
                fmt.Print("  ")
            } else {
                fmt.Printf("%c ", column)
            }
        }
        fmt.Println()
    }
}
func main() {
    var board [8][8]rune
    // black pieces
    board[0][0] = 'r'
    board[0][1] = 'n'
    board[0][2] = 'b'
    board[0][3] = 'q'
    board[0][4] = 'k'
    board[0][5] = 'b'
    board[0][6] = 'n'
    board[0][7] = 'r'
    // pawns
    for column := range board[1] {
        board[1][column] = 'p'
        board[6][column] = 'P'
    }
    // white pieces
    board[7][0] = 'R'
    board[7][1] = 'N'
    board[7][2] = 'B'
    board[7][3] = 'Q'
    board[7][4] = 'K'
    board[7][5] = 'B'
    board[7][6] = 'N'
    board[7][7] = 'R'
    display(board)
}