Array & Slice di Go

Array (Ukuran Tetap)

Array di Go memiliki ukuran yang tidak bisa berubah setelah dideklarasikan:

var angka [3]int = [3]int{10, 20, 30}
// atau
buah := [3]string{"apel", "jeruk", "mangga"}

fmt.Println(buah[0]) // "apel"
fmt.Println(len(buah)) // 3

Slice (Ukuran Dinamis)

Slice jauh lebih umum digunakan dibanding array. Slice bisa bertambah ukurannya:

// Membuat slice
angka := []int{1, 2, 3, 4, 5}

// Menggunakan make
skor := make([]int, 0, 10) // length 0, capacity 10

Operasi Slice

s := []int{10, 20, 30, 40, 50}

// Append (menambah elemen)
s = append(s, 60, 70)

// Slicing
fmt.Println(s[1:3]) // [20 30]
fmt.Println(s[:3])  // [10 20 30]
fmt.Println(s[3:])  // [40 50 60 70]

// Length dan Capacity
fmt.Println(len(s)) // jumlah elemen
fmt.Println(cap(s)) // kapasitas

Iterasi Slice

buah := []string{"apel", "jeruk", "mangga"}
for i, b := range buah {
    fmt.Printf("%d: %s\n", i, b)
}

Gotcha: Shared Backing Array

Ini bug klasik yang sering menjebak developer Go. Slice secara internal adalah header (pointer + length + capacity) yang menunjuk ke array di memori. Ketika kamu membuat slice dari slice, keduanya menunjuk ke array yang sama:

a := []int{1, 2, 3, 4, 5}
b := a[1:3]   // b = [2, 3]
b[0] = 99     // mengubah b…

fmt.Println(a) // [1 99 3 4 5] — a ikut berubah!
fmt.Println(b) // [99 3]

Bahkan append pun bisa menimpa data slice asli jika kapasitas masih cukup:

a := []int{1, 2, 3, 4, 5}
b := a[:2]          // b = [1, 2], cap(b) = 5
b = append(b, 99)   // menulis ke posisi index 2 di array yang SAMA
fmt.Println(a)      // [1 2 99 4 5] — surprise!

Solusi: copy ke slice baru agar tidak berbagi memori:

b := make([]int, 2)
copy(b, a[1:3])     // b punya backing array sendiri

// Atau idiom yang lebih singkat:
b := append([]int{}, a[1:3]...)

Selalu sadari: kapan slice berbagi memori, kapan sudah dipisahkan. Ini juga berlaku ketika kamu mengirim slice sebagai parameter fungsi — fungsi bisa memodifikasi data asli tanpa pointer eksplisit.