Array vs Slice di Golang: Perbedaan, Cara Kerja & Penggunaan

Ringkasan

• Array memiliki ukuran tetap (fixed-length) yang menjadi bagian dari tipe datanya, cocok untuk data yang jumlahnya pasti.
• Slice adalah struktur dinamis yang bertindak sebagai jendela (view) ke array, memungkinkan penambahan data secara fleksibel melalui fungsi append().
• Efisiensi Memori: Array dikirim sebagai salinan utuh (value type), sedangkan slice dikirim sebagai header ringan (reference type), membuatnya jauh lebih efisien untuk data besar.
• Kapan Memilih: Gunakan slice untuk hampir semua kasus umum di Go, dan gunakan array hanya untuk optimasi tingkat rendah atau buffer berukuran tetap.

Bagi banyak pengembang yang baru berpindah ke bahasa pemrograman Go (Golang), perbedaan antara Array dan Slice seringkali membingungkan. Sekilas, keduanya terlihat identik karena sama-sama digunakan untuk menyimpan kumpulan data bertipe sama dalam satu variabel. Namun, di balik layar, mekanisme manajemen memori dan perilakunya sangat berbeda.

Memahami perbedaan mendalam antara keduanya bukan sekadar masalah sintaksis, melainkan masalah performa. Salah memilih struktur data dapat menyebabkan penggunaan memori yang boros atau bug yang sulit dilacak saat aplikasi Anda berkembang menjadi sistem skala besar.

Apa Itu Array di Golang?

Array adalah struktur data yang menyimpan sekumpulan elemen dengan tipe yang sama dan memiliki ukuran yang tetap (fixed-length). Sekali Anda mendeklarasikan array dengan ukuran tertentu, ukuran tersebut tidak dapat diubah selama program berjalan.

Karakteristik Utama Array

Salah satu hal paling unik dari array di Go adalah bahwa ukuran array merupakan bagian dari tipe datanya. Ini berarti [5]int dan [10]int adalah dua tipe data yang sepenuhnya berbeda. Anda tidak bisa memasukkan array berukuran 5 ke dalam variabel yang mengharapkan array berukuran 10.

Contoh Deklarasi Array:

// Deklarasi array dengan ukuran 5
var arr [5]int
arr[0] = 10

// Inisialisasi langsung (Literal)
arrLiteral := [5]int{10, 20, 30, 40, 50}

Kapan Harus Menggunakan Array?

Karena sifatnya yang kaku, array jarang digunakan dalam pengembangan aplikasi bisnis sehari-hari. Namun, array sangat berguna dalam skenario berikut:

• Buffer Berukuran Tetap: Misalnya saat membaca data dari network socket dengan ukuran paket yang sudah ditentukan.
• Kriptografi: Banyak algoritma hashing (seperti SHA-256) yang menghasilkan output dengan panjang byte yang tetap.
• Optimasi Memori Tingkat Rendah: Ketika Anda ingin menghindari alokasi memori dinamis di heap untuk mengurangi beban Garbage Collector (GC).

Apa Itu Slice di Golang?

Slice adalah versi fleksibel dari array. Secara teknis, slice bukanlah array itu sendiri, melainkan sebuah deskriptor atau pembungkus (wrapper) yang merujuk ke sebuah array yang ada di latar belakang (underlying array). Slice memberikan cara yang jauh lebih efisien dan mudah untuk mengelola urutan data.

Anatomi Internal Slice

Sebuah slice terdiri dari tiga komponen utama yang disimpan dalam sebuah struktur kecil (slice header):

1. Pointer: Alamat memori yang menunjuk ke elemen pertama array yang dapat diakses oleh slice tersebut.
2. Length (Panjang): Jumlah elemen yang saat ini ada di dalam slice.
3. Capacity (Kapasitas): Jumlah total elemen yang dapat ditampung oleh array di belakang slice, mulai dari pointer awal hingga akhir array tersebut.

Contoh Deklarasi Slice:

// Deklarasi slice (tanpa angka di dalam kurung siku)
slice := []int{10, 20, 30}

// Menambahkan elemen secara dinamis
slice = append(slice, 40, 50)

Mekanisme Fungsi append()

Fungsi append() adalah jantung dari fleksibilitas slice. Saat Anda menambahkan elemen baru, Go akan memeriksa apakah kapasitas (capacity) masih mencukupi. Jika masih ada ruang, Go hanya akan menambah panjang (length) dan memasukkan data baru.

Namun, jika kapasitas sudah penuh, Go akan melakukan proses berikut secara otomatis:

• Membuat array baru yang lebih besar (biasanya dua kali lipat dari ukuran sebelumnya).
• Menyalin semua data dari array lama ke array baru.
• Menambahkan elemen baru ke array tersebut.
• Memperbarui pointer slice untuk merujuk ke array baru ini.

Perbandingan Mendalam: Array vs Slice

1. Pengiriman ke Fungsi (Pass by Value vs Reference)

Ini adalah perbedaan yang paling krusial bagi performa aplikasi. Di Go, segala sesuatu dikirim sebagai value. Namun, karena array adalah tipe nilai murni, saat Anda mengirim array ke fungsi, Go akan menyalin seluruh isi array tersebut. Jika array Anda berisi 1 juta elemen, maka 1 juta elemen tersebut akan disalin ke memori baru.

Sebaliknya, saat Anda mengirim slice, yang dikirim hanyalah slice header (pointer, length, dan capacity). Karena hanya header kecil yang disalin, proses ini sangat cepat dan efisien, tidak peduli seberapa besar data yang ada di dalam slice tersebut.

2. Fleksibilitas Ukuran

Array bersifat statis. Jika Anda membutuhkan lebih banyak ruang, Anda harus membuat array baru dan menyalin datanya secara manual. Slice bersifat dinamis; ia dapat tumbuh dan menyusut sesuai kebutuhan aplikasi Anda melalui fungsi append() atau teknik reslicing.

Tabel Perbandingan Ringkas

Aspek	Array	Slice
Ukuran	Tetap (Fixed)	Dinamis
Deklarasi	[5]int	[]int
Pertumbuhan	Tidak bisa bertambah	Bisa (via append())
Pengiriman Fungsi	Disalin seluruhnya (Berat)	Hanya header (Ringan)
Tipe Data	Ukuran adalah bagian dari tipe	Tipe umum untuk koleksi data
Penggunaan	Kasus khusus/Optimasi	Sangat sering (Standar Go)

Tips Praktis dalam Menggunakan Slice

Untuk menulis kode Go yang lebih profesional dan efisien, pertimbangkan tips berikut:

Gunakan make() untuk Pre-alokasi

Jika Anda sudah mengetahui perkiraan jumlah data yang akan masuk ke dalam slice, gunakan fungsi make() untuk menentukan kapasitas awal. Ini mencegah Go melakukan alokasi ulang memori berkali-kali saat fungsi append() dipanggil.

// Kurang efisien: alokasi terjadi berulang kali
var data []int
for i := 0; i < 1000; i++ {
    data = append(data, i)
}

// Lebih efisien: alokasi memori dilakukan sekali di awal
data := make([]int, 0, 1000)
for i := 0; i < 1000; i++ {
    data = append(data, i)
}

Hati-hati dengan Memory Leak pada Reslicing

Karena slice merujuk ke array di belakangnya, jika Anda membuat slice kecil dari array yang sangat besar, array besar tersebut akan tetap berada di memori selama slice kecil itu masih digunakan. Untuk mengatasinya, Anda bisa menyalin data yang dibutuhkan ke slice baru menggunakan fungsi copy().

Kesimpulan

Array dan slice mungkin terlihat mirip, tetapi mereka melayani tujuan yang berbeda. Array memberikan kepastian dan kontrol ketat atas memori, sementara slice memberikan fleksibilitas dan kemudahan pengembangan.

Bagi pengembang Go, aturan praktisnya sederhana: Gunakan slice untuk hampir semua hal. Gunakan array hanya jika Anda memiliki alasan teknis yang sangat spesifik terkait ukuran data yang tidak boleh berubah atau kebutuhan optimasi memori tingkat rendah. Dengan menguasai konsep length, capacity, dan cara kerja underlying array, Anda akan dapat mengelola koleksi data di Go dengan jauh lebih efektif dan efisien.