Slice trong Golang: append, make, len, cap và lỗi dùng chung

Slice qua một ví dụ

Slice là một khung nhìn có thể mở rộng lên một mảng. Bạn tạo slice bằng literal hoặc bằng make, mở rộng bằng append, và lấy kích thước bằng len.

package main

import "fmt"

func main() {
	langs := []string{"Go", "Rust"}
	langs = append(langs, "Zig", "C")
	fmt.Println(langs, len(langs))

	for i, l := range langs {
		fmt.Println(i, l)
	}

	fmt.Println(langs[1:3]) // elements 1 and 2
}

[]string không có độ dài trong ngoặc vuông. Đó là điểm khác với kiểu mảng như [4]string, có kích thước cố định.

Slice là gì

Một giá trị slice là một header nhỏ gồm ba trường:

• một con trỏ tới một phần tử trong mảng nền
• độ dài: số phần tử slice nhìn thấy
• dung lượng: số phần tử có từ vị trí con trỏ đến cuối mảng nền

Sao chép một slice (gán nó, truyền nó vào hàm) chỉ sao chép header này. Cả hai bản sao cùng trỏ tới những phần tử giống nhau. Gần như mọi bất ngờ với slice đều đến từ việc quên điều đó.

make: độ dài và dung lượng

make([]T, len, cap) cấp phát một mảng nền và trả về một slice trên mảng đó. Dung lượng là tùy chọn, mặc định bằng độ dài.

package main

import "fmt"

func main() {
	a := make([]int, 3) // len 3, cap 3, all zeros
	fmt.Println(a, len(a), cap(a))

	b := make([]int, 0, 10) // len 0, room for 10
	fmt.Println(b, len(b), cap(b))

	for i := range 5 {
		b = append(b, i*i)
	}
	fmt.Println(b, len(b), cap(b)) // no reallocation happened
}

Một nhầm lẫn hay gặp: make([]int, 5) rồi gọi append năm lần sẽ cho bạn mười phần tử, năm phần tử đầu là 0. Dùng make([]int, 0, 5) khi định append, hoặc make([]int, 5) khi định gán theo chỉ số.

Cấp phát trước dung lượng khi đã biết kích thước cuối cùng giúp tránh việc mở rộng lặp đi lặp lại. Đây là tối ưu hóa, không phải yêu cầu bắt buộc.

append và cách slice mở rộng

append thêm phần tử vào sau độ dài hiện tại. Nếu dung lượng đủ lớn, nó ghi ngay tại chỗ. Nếu không, nó cấp phát một mảng lớn hơn, sao chép các phần tử cũ sang, và trả về một slice trỏ tới mảng mới.

package main

import "fmt"

func main() {
	var s []int
	prevCap := cap(s)
	for i := range 2000 {
		s = append(s, i)
		if cap(s) != prevCap {
			fmt.Printf("len %4d  cap %4d\n", len(s), cap(s))
			prevCap = cap(s)
		}
	}
}

Dung lượng tăng khoảng gấp đôi khi slice còn nhỏ, và tăng theo hệ số nhỏ hơn (tiến dần về 1,25 lần) khi vượt quá 256 phần tử. Con số chính xác là chi tiết của runtime và đã thay đổi qua các phiên bản Go, nên đừng bao giờ viết code phụ thuộc vào nó.

Vì append có thể trả về một mảng khác, bạn phải dùng kết quả của nó:

append(s, 4)     // compile error: append(s, 4) (value of type []int) is not used
s = append(s, 4) // correct

Thêm cả một slice dùng cú pháp trải: s = append(s, other...).

Cắt slice dùng chung mảng nền

s[low:high] tạo một header slice mới trên cùng mảng đó, bao gồm các chỉ số từ low đến trước high. Có thể bỏ trống bất kỳ cận nào. Không phần tử nào bị sao chép.

package main

import "fmt"

func main() {
	nums := []int{10, 20, 30, 40, 50}
	mid := nums[1:4] // 20 30 40
	mid[0] = 99
	fmt.Println(nums) // the write shows up in nums

	fmt.Println(len(mid), cap(mid)) // cap runs to the end of nums
}

Đầu ra:

[10 99 30 40 50]
3 4

Việc dùng chung đó khiến cắt slice rất rẻ. Nó cũng là nguồn gốc của lỗi slice nổi tiếng nhất.

Lỗi append dùng chung vùng nhớ

Khi một slice con còn dung lượng trống, append vào nó sẽ ghi vào mảng của slice cha, đè lên những phần tử mà slice cha vẫn đang dùng.

package main

import "fmt"

func main() {
	base := []int{1, 2, 3, 4, 5}
	first := base[:2] // [1 2], cap 5

	first = append(first, 100) // fits in capacity: overwrites base[2]
	fmt.Println(base)
	fmt.Println(first)

	// Two slices built from the same prefix clobber each other.
	prefix := make([]string, 0, 4)
	prefix = append(prefix, "cmd")
	a := append(prefix, "build")
	b := append(prefix, "test")
	fmt.Println(a, b) // both print test
}

Đầu ra:

[1 2 100 4 5]
[1 2 100]
[cmd test] [cmd test]

a và b dùng chung ô mảng ngay sau "cmd", nên lần append thứ hai ghi đè lần thứ nhất. Đoạn code trông ổn và chạy đúng mỗi khi dung lượng tình cờ đã đầy, vì thế lỗi này chỉ thỉnh thoảng mới xuất hiện.

Hai cách sửa:

1. Biểu thức cắt đầy đủ s[low:high:max] giới hạn dung lượng ở max-low. Không còn dung lượng trống, lần append tiếp theo buộc phải cấp phát. first := base[:2:2] làm ví dụ đầu tiên trở nên an toàn.
2. Sao chép tường minh khi một slice sẽ tồn tại lâu hơn lời gọi hàm hoặc được append độc lập: slices.Clone(prefix) hoặc append([]string(nil), prefix...).

Một cái bẫy liên quan: một slice nhỏ của một mảng khổng lồ giữ cả mảng đó sống với bộ thu gom rác. Nếu bạn đọc một tệp 100 MB rồi giữ lại data[:10], cả 100 MB vẫn nằm trong bộ nhớ. Hãy clone phần bạn giữ lại.

copy

Hàm có sẵn copy(dst, src) sao chép min(len(dst), len(src)) phần tử và trả về số đó. Nó không bao giờ mở rộng dst.

package main

import (
	"fmt"
	"slices"
)

func main() {
	src := []int{1, 2, 3}

	dst := make([]int, len(src))
	n := copy(dst, src)
	dst[0] = 100
	fmt.Println(n, src, dst) // independent

	var empty []int
	fmt.Println(copy(empty, src)) // 0: dst has no length

	c := slices.Clone(src) // the one-line version (Go 1.21)
	fmt.Println(c)
}

copy xử lý đúng khi nguồn và đích chồng lên nhau, nên copy(s[1:], s) dịch các phần tử sang phải mà không làm hỏng dữ liệu.

Package slices

Từ Go 1.21, package chuẩn slices có các hàm generic cho những thao tác trước đây bạn phải tự viết.

package main

import (
	"fmt"
	"slices"
)

func main() {
	s := []int{5, 2, 8, 2, 9}

	fmt.Println(slices.Contains(s, 8)) // true
	fmt.Println(slices.Index(s, 2))    // 1
	fmt.Println(slices.Max(s), slices.Min(s))

	slices.Sort(s)
	fmt.Println(s)
	i, found := slices.BinarySearch(s, 8)
	fmt.Println(i, found)

	s = slices.Compact(s) // drop adjacent duplicates
	fmt.Println(s)

	s = slices.Delete(s, 1, 2) // remove index 1
	fmt.Println(s)

	s = slices.Insert(s, 1, 3, 4)
	fmt.Println(s)

	slices.Reverse(s)
	fmt.Println(s, slices.Equal(s, []int{9, 8, 4, 3, 2}))
}

Delete và Insert trả về một slice mà bạn phải gán lại, giống append. Sắp xếp có trang riêng: sắp xếp.

Xóa phần tử trong khi lặp theo chỉ số sẽ bỏ sót phần tử. Hãy dùng slices.DeleteFunc:

s = slices.DeleteFunc(s, func(n int) bool { return n%2 == 0 }) // drop evens

Slice 2 chiều

Slice của slice cho bạn một lưới mà các hàng có thể dài ngắn khác nhau. Mỗi hàng phải được cấp phát riêng.

package main

import "fmt"

func main() {
	rows, cols := 3, 4
	grid := make([][]int, rows)
	for r := range grid {
		grid[r] = make([]int, cols)
	}
	grid[1][2] = 7

	for _, row := range grid {
		fmt.Println(row)
	}

	// Rows of different lengths are fine.
	triangle := [][]int{{1}, {1, 1}, {1, 2, 1}}
	fmt.Println(triangle)
}

Quên make bên trong thì mỗi hàng là nil, và grid[1][2] = 7 gây panic với thông báo index out of range [2] with length 0.

Slice nil và slice rỗng

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	var a []int  // nil
	b := []int{} // empty, not nil

	fmt.Println(len(a), len(b), a == nil, b == nil)

	a = append(a, 1) // append works on nil
	fmt.Println(a)

	ja, _ := json.Marshal(struct{ Items []int }{})
	jb, _ := json.Marshal(struct{ Items []int }{Items: []int{}})
	fmt.Println(string(ja), string(jb))
}

Slice nil hoạt động như slice rỗng với len, cap, range và append, nên hãy ưu tiên var s []T làm trạng thái ban đầu. Chỉ khởi tạo bằng []T{} khi khác biệt có ý nghĩa, chủ yếu là đầu ra JSON (null so với []). Kiểm tra rỗng bằng len(s) == 0, không phải s == nil.

Slice và hàm

Hàm nhận một slice có thể thay đổi các phần tử của nó, và nơi gọi sẽ thấy thay đổi. Hàm không thể đổi độ dài của slice bên nơi gọi, vì nó chỉ nhận một bản sao của header. Hàm có append phải trả về slice mới:

func addAll(s []int, vals ...int) []int {
	return append(s, vals...)
}

Đây là lý do append, slices.Delete và slices.Insert đều trả về một slice.

Lỗi thường gặp

• Bỏ qua kết quả của append. Bỏ hẳn kết quả thì không biên dịch được, nhưng gán append(s, x) cho một biến khác với biến bạn tiếp tục dùng là lỗi logic.
• Hai lần append từ cùng một slice gốc. Chúng có thể dùng chung vùng nhớ. Hãy clone slice gốc hoặc dùng biểu thức cắt đầy đủ.
• make([]T, n) rồi append. Để lại n số 0 ở đầu.
• Chỉ số vượt phạm vi. s[len(s)] gây panic. Phần tử cuối là s[len(s)-1].
• So sánh slice bằng ==. Chỉ s == nil biên dịch được. Hãy dùng slices.Equal.