Slice

Daftar fleksibel yang menjadi koleksi utama di Go.

Pahami konsepnya

Slice adalah daftar fleksibel bertipe sama dan koleksi yang paling sering kamu pakai di Go. Deklarasinya tanpa angka: []int atau []string dengan literal, atau lewat make([]int, panjang) bila mulai kosong.

Slice sejatinya jendela menuju array di belakangnya — ia menyimpan penunjuk, panjang (len), dan kapasitas (cap). Mengambil nilai[1:3] membuat slice baru yang menunjuk memori yang sama, sehingga mengubah elemen lewat satu slice terlihat dari slice lain yang berbagi array itu. cap mengukur ruang sisa sebelum slice harus pindah ke memori baru.

append menambah elemen di akhir dan mengembalikan slice hasil — wajib ditampung kembali. Saat kapasitas penuh, Go menyiapkan array baru lebih besar; saat masih longgar, elemen baru menempati ruang kosong yang mungkin masih dibagi slice lain. copy(dst, src) menyalin min(len(dst), len(src)) elemen. Bentuk tiga indeks nilai[0:2:2] sekaligus memotong kapasitasnya, dan paket slices (Go 1.21+) menambah utilitas modern: Sort, Contains, Index, Reverse.

Coba contoh kode

package main

import (
    "fmt"
    "slices"
)

func main() {
    nilai := []int{80, 90, 75}
    nilai = append(nilai, 100)
    potongan := nilai[1:3]
    fmt.Println(len(nilai), cap(nilai), potongan)
}

append(nilai, 100) membuat slice berisi empat angka. potongan := nilai[1:3] mengambil elemen indeks 1 dan 2 (90 dan 75) — panjangnya 2, tetapi cap-nya masih mengikuti array asal sampai akhir. Coba potongan[0] = 999 lalu cetak nilai: elemen indeks 1 ikut berubah, bukti memori dibagi.

copy dan append yang menimpa

func main() {
    asal := []int{1, 2, 3, 4, 5}
    tujuan := make([]int, 2)
    n := copy(tujuan, asal)
    fmt.Println(n, tujuan) // 2 [1 2]

    a := asal[0:2]                 // len 2, cap 5
    b := append(a, 99)
    fmt.Println(asal)              // [1 2 99 4 5] — indeks 2 tertimpa!
}

copy hanya memindahkan sejumlah elemen yang muat di tujuan. Jebakan kedua lebih halus: a masih punya kapasitas sisa, jadi append(a, 99) menulis LANGSUNG ke ruang kosong array asal dan menimpa elemen indeks 2 milik asal. Saat slice berbagi array, append bisa menimpa data tetangga.

Paket slices

func main() {
    nama := []string{"adi", "citra", "budi"}
    slices.Sort(nama)
    fmt.Println(nama)                         // [adi budi citra]
    fmt.Println(slices.Contains(nama, "budi")) // true
    fmt.Println(slices.Index(nama, "citra"))   // 2
}

Sejak Go 1.21, paket slices membungkus operasi umum dengan aman dan generik: Sort mengurutkan, Contains memeriksa keberadaan, Index mencari posisi. Utilitas lama di paket sort kini pelan-pelan digantikan ini.

Latihan singkat

Uji: ambil tiga nama pertama, ubah elemen pertamanya menjadi `zeta`, cetak nama; lalu urutkan potongan itu dan cetak. Keluaran harus `[zeta budi citra andi erik]` lalu `[budi citra zeta]`.