Mảng trong Golang: độ dài cố định, sao chép khi gán, vs slice

Khai báo mảng

Kiểu mảng (array) được viết là [N]T: một độ dài, rồi đến kiểu phần tử. Độ dài được cố định lúc biên dịch và là một phần của kiểu.

package main

import "fmt"

func main() {
	var scores [5]int // five zeros
	scores[0] = 90
	scores[4] = 75
	fmt.Println(scores, len(scores))

	days := [3]string{"Mon", "Tue", "Wed"}
	fmt.Println(days[1])

	primes := [...]int{2, 3, 5, 7, 11} // compiler counts: [5]int
	fmt.Printf("%T %v\n", primes, primes)

	// Index keys: unset positions get the zero value.
	sparse := [5]string{1: "b", 3: "d"}
	fmt.Printf("%q\n", sparse)
}

Đầu ra:

[90 0 0 0 75] 5
Tue
[5]int [2 3 5 7 11]
["" "b" "" "d" ""]

Mảng luôn được khởi tạo đầy đủ. Phần tử nào bạn không gán sẽ mang giá trị zero của kiểu phần tử: 0, "", false, nil.

Chỉ số và giới hạn

Chỉ số chạy từ 0 đến len(a)-1. Một chỉ số hằng nằm ngoài phạm vi là lỗi biên dịch. Một chỉ số là biến nằm ngoài phạm vi sẽ gây panic lúc chạy.

var a [3]int
a[5] = 1 // compile error: invalid argument: index 5 out of bounds [0:3]

i := 5
a[i] = 1 // panic: runtime error: index out of range [5] with length 3

Duyệt mảng

for i, v := range a đi qua từng phần tử theo thứ tự. v là bản sao của phần tử, nên gán vào v không làm thay đổi mảng. Hãy ghi qua chỉ số.

package main

import "fmt"

func main() {
	temps := [4]float64{21.5, 23.0, 19.8, 25.1}

	sum := 0.0
	for _, t := range temps {
		sum += t
	}
	fmt.Printf("average: %.2f\n", sum/float64(len(temps)))

	for i := range temps {
		temps[i] += 1 // modifies the array
	}
	fmt.Println(temps)
}

Có thêm một điểm tinh tế chỉ riêng mảng mới có: range trên một giá trị mảng sẽ lấy bản sao của mảng ngay từ đầu. Nếu thân vòng lặp sửa các phần tử phía sau, v vẫn cho thấy giá trị cũ. Duyệt qua &a hoặc a[:] sẽ tránh được bản sao này.

Mảng là giá trị

Đây là điểm khác biệt chính so với mảng trong C, Java hay JavaScript. Gán một mảng sẽ sao chép mọi phần tử. Truyền mảng vào hàm cũng sao chép nó.

package main

import "fmt"

func reset(a [3]int) {
	a[0] = 0 // changes the function's copy
}

func resetPtr(a *[3]int) {
	a[0] = 0 // changes the caller's array
}

func main() {
	a := [3]int{1, 2, 3}
	b := a // full copy
	b[0] = 99
	fmt.Println(a, b)

	reset(a)
	fmt.Println(a)

	resetPtr(&a)
	fmt.Println(a)
}

Đầu ra:

[1 2 3] [99 2 3]
[1 2 3]
[0 2 3]

Sao chép mảng nhỏ thì rẻ, mảng lớn thì tốn: truyền một [1_000_000]int theo giá trị sẽ sao chép tám megabyte. Hãy truyền con trỏ (*[N]T) hoặc slice (a[:]) khi mảng lớn hoặc khi hàm cần thay đổi nó. Truy cập chỉ số qua con trỏ mảng không cần viết *: a[0] dùng được trên một *[3]int.

So sánh mảng và dùng mảng làm khóa của map

Mảng gồm các phần tử so sánh được hỗ trợ == và !=. Hai mảng bằng nhau khi từng phần tử bằng nhau. Điều đó cũng khiến mảng hợp lệ để làm khóa của map, còn slice thì không.

package main

import "fmt"

func main() {
	x := [3]int{1, 2, 3}
	y := [3]int{1, 2, 3}
	fmt.Println(x == y)

	// A grid position as a map key.
	type pos [2]int
	visited := map[pos]bool{}
	visited[pos{0, 0}] = true
	visited[pos{2, 1}] = true
	fmt.Println(visited[pos{2, 1}], visited[pos{1, 1}])
}

Các mảng có độ dài khác nhau là các kiểu khác nhau và hoàn toàn không so sánh được: [3]int{} == [4]int{} không biên dịch được (mismatched types [3]int and [4]int).

Mảng nhiều chiều

Một mảng chứa các mảng cho bạn một lưới cố định. Toàn bộ lưới là một khối bộ nhớ liền mạch.

package main

import "fmt"

func main() {
	var board [3][3]rune
	for r := range board {
		for c := range board[r] {
			board[r][c] = '.'
		}
	}
	board[1][1] = 'X'
	board[0][2] = 'O'

	for _, row := range board {
		fmt.Println(string(row[:]))
	}
}

row[:] biến hàng [3]rune thành một slice []rune, kiểu mà string() chấp nhận.

Mảng so với slice

Trên thực tế, bạn chủ yếu gặp mảng ở vài chỗ: sha256.Sum256 trả về một [32]byte, các bảng tra cứu có kích thước không bao giờ đổi, và làm vùng lưu trữ phía sau một slice. Cắt mảng bằng a[:] hoặc a[1:3] tạo ra một slice dùng chung bộ nhớ với mảng; trang slices giải thích việc dùng chung này nghĩa là gì.

Chuyển đổi giữa mảng và slice

package main

import "fmt"

func main() {
	arr := [4]int{1, 2, 3, 4}
	s := arr[:] // slice view: shares memory with arr
	s[0] = 100
	fmt.Println(arr)

	nums := []int{7, 8, 9}
	a := [3]int(nums) // Go 1.20: slice to array, copies
	nums[0] = 0
	fmt.Println(a, nums)

	p := (*[3]int)(nums) // Go 1.17: array pointer, shares memory
	p[1] = 0
	fmt.Println(nums)
}

Chuyển một slice thành mảng (Go 1.20) hoặc con trỏ mảng (Go 1.17) sẽ gây panic nếu slice ngắn hơn độ dài mảng: panic: runtime error: cannot convert slice with length 2 to array or pointer to array with length 3.

Lỗi thường gặp

• Mong một hàm sửa được mảng truyền vào. Hàm chỉ nhận một bản sao. Hãy truyền *[N]T hoặc slice.
• Dùng mảng ở chỗ cần slice. []int{1, 2} là slice, [2]int{1, 2} là mảng. Một hàm nhận []int sẽ không chấp nhận [2]int; hãy truyền a[:].
• Mảng lớn trong vòng lặp range. for _, v := range bigArray sao chép toàn bộ mảng trước. Hãy duyệt qua &bigArray hoặc một slice.