Slice di Golang: append, make, len vs cap, dan Bug Berbagi Array

Slice dalam satu contoh

Slice adalah tampilan (view) yang bisa membesar ke sebuah array. Kamu membuatnya dengan literal atau dengan make, menambahnya dengan append, dan membaca ukurannya dengan 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 tidak punya panjang di dalam kurung siku. Itulah perbedaannya dengan tipe array seperti [4]string, yang ukurannya tetap.

Apa itu slice

Nilai slice adalah header kecil dengan tiga field:

• pointer ke sebuah elemen di backing array
• length: berapa banyak elemen yang bisa dilihat slice itu
• capacity: berapa banyak elemen yang ada dari pointer itu sampai akhir backing array

Menyalin slice (meng-assign-nya, mengirimkannya ke fungsi) hanya menyalin header ini. Kedua salinan menunjuk ke elemen-elemen yang sama. Hampir setiap kejutan soal slice berasal dari lupa akan hal ini.

make: length dan capacity

make([]T, len, cap) mengalokasikan backing array dan mengembalikan slice di atasnya. Capacity bersifat opsional dan secara default sama dengan length.

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
}

Kekeliruan yang umum: make([]int, 5) diikuti lima pemanggilan append menghasilkan sepuluh elemen, lima yang pertama bernilai nol. Pakai make([]int, 0, 5) kalau kamu berencana melakukan append, atau make([]int, 5) kalau kamu berencana meng-assign berdasarkan indeks.

Mengalokasikan capacity lebih dulu saat kamu tahu ukuran akhirnya akan menghindari pertumbuhan berulang. Ini optimasi, bukan keharusan.

append dan pertumbuhan

append menambahkan elemen setelah length saat ini. Kalau capacity-nya cukup, ia menulis di tempat. Kalau tidak, ia mengalokasikan array yang lebih besar, menyalin elemen lama ke sana, lalu mengembalikan slice yang menunjuk ke array baru.

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)
		}
	}
}

Capacity kira-kira berlipat dua selama slice masih kecil, dan tumbuh dengan faktor yang lebih kecil (mendekati 1,25x) begitu melewati 256 elemen. Angka pastinya adalah detail runtime yang sudah berubah antarversi Go, jadi jangan pernah menulis kode yang bergantung padanya.

Karena append bisa mengembalikan array yang berbeda, kamu harus memakai hasilnya:

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

Menambahkan seluruh isi slice memakai sintaks spread: s = append(s, other...).

Slicing berbagi backing array

s[low:high] membuat header slice baru di atas array yang sama, mencakup indeks low sampai sebelum high. Batas mana pun boleh dihilangkan. Tidak ada elemen yang disalin.

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
}

Output:

[10 99 30 40 50]
3 4

Berbagi array itulah yang membuat slicing murah. Dan itu juga sumber bug slice yang paling terkenal.

Bug aliasing pada append

Saat sebuah sub-slice punya capacity tersisa, append ke sub-slice itu akan menulis ke array milik induknya, menimpa elemen yang masih dipakai induknya.

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
}

Output:

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

a dan b berbagi slot array setelah "cmd", jadi append yang kedua menimpa yang pertama. Kodenya terlihat baik-baik saja dan berjalan benar setiap kali capacity-nya kebetulan penuh, itulah sebabnya bug ini hanya muncul sesekali.

Dua cara memperbaikinya:

1. Full slice expression s[low:high:max] membatasi capacity menjadi max-low. Tanpa capacity tersisa, append berikutnya terpaksa mengalokasikan array baru. first := base[:2:2] membuat contoh pertama aman.
2. Salin secara eksplisit saat sebuah slice akan dipakai lebih lama dari pemanggilannya atau di-append secara terpisah: slices.Clone(prefix) atau append([]string(nil), prefix...).

Jebakan yang berkaitan: slice kecil dari array yang sangat besar membuat seluruh array tetap hidup bagi garbage collector. Kalau kamu membaca file 100 MB lalu menyimpan data[:10], 100 MB itu tetap ada di memori. Clone bagian yang kamu simpan.

copy

Fungsi bawaan copy(dst, src) menyalin min(len(dst), len(src)) elemen dan mengembalikan jumlah itu. Fungsi ini tidak pernah memperbesar 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 menangani sumber dan tujuan yang tumpang tindih dengan benar, jadi copy(s[1:], s) menggeser elemen ke kanan tanpa merusaknya.

Package slices

Sejak Go 1.21, package standar slices punya helper generic untuk operasi yang dulu harus kamu tulis sendiri.

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 dan Insert mengembalikan slice yang harus kamu assign, sama seperti append. Pengurutan punya halamannya sendiri: pengurutan.

Menghapus elemen sambil melakukan perulangan berdasarkan indeks akan melewatkan beberapa elemen. Pakai slices.DeleteFunc sebagai gantinya:

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

Slice 2D

Slice berisi slice memberimu grid yang panjang setiap barisnya bisa berbeda. Setiap baris harus dialokasikan secara terpisah.

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)
}

Lupa melakukan make di bagian dalam membuat setiap baris bernilai nil, dan grid[1][2] = 7 akan panic dengan index out of range [2] with length 0.

Slice nil dan slice kosong

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 berperilaku seperti slice kosong untuk len, cap, range, dan append, jadi pakai var s []T sebagai keadaan nol. Inisialisasi ke []T{} hanya kalau perbedaannya penting, yang kebanyakan terjadi pada output JSON (null vs []). Periksa kekosongan dengan len(s) == 0, bukan s == nil.

Slice dan fungsi

Fungsi yang menerima slice bisa mengubah elemennya, dan pemanggil melihat perubahan itu. Fungsi itu tidak bisa mengubah length milik pemanggil, karena yang diterimanya adalah salinan header. Fungsi yang melakukan append harus mengembalikan slice baru:

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

Inilah sebabnya append, slices.Delete, dan slices.Insert semuanya mengembalikan slice.

Kesalahan umum

• Mengabaikan hasil append. Tidak bisa dikompilasi kalau dibuang sepenuhnya, tapi append(s, x) yang di-assign ke variabel lain selain yang terus kamu pakai adalah bug logika.
• Dua append dari satu slice dasar. Keduanya bisa berbagi tempat penyimpanan. Clone slice dasarnya atau pakai full slice expression.
• make([]T, n) lalu append. Menyisakan n angka nol di bagian depan.
• Index out of range. s[len(s)] akan panic. Elemen terakhir adalah s[len(s)-1].
• Membandingkan slice dengan ==. Hanya s == nil yang bisa dikompilasi. Pakai slices.Equal.