Memori: nilai dan referensi
Kenapa mengubah satu variabel kadang ikut mengubah variabel lain. Nilai vs referensi, shallow vs deep copy, garbage collection, dan jebakan default argument di Python, lengkap dengan output asli.
Cepat atau lambat, setiap programmer akan menulis kode seperti ini lalu kaget:
x = [1, 2, 3]
y = x
y.append(4)
print(x) # [1, 2, 3, 4]
Yang kita ubah cuma y. Kenapa x ikut berubah? Jawabannya adalah salah satu hal paling berguna untuk dipahami sejak awal: perbedaan antara nilai (value) dan referensi (reference). Bagian sebelumnya membahas arti bit di memori. Bagian ini membahas bagaimana variabel menunjuk ke sana.
Variabel adalah nama, bukan kotak
Cara umum menjelaskan variabel adalah “kotak yang berisi nilai”. Gambaran itu cocok untuk hal kecil seperti angka, tapi mulai tidak tepat untuk list, objek, dan apa pun yang lebih besar. Gambaran yang lebih akurat: variabel adalah nama yang menunjuk ke sesuatu di memori.
FAQ Python menyatakannya langsung: “Variables are simply names that refer to objects.” Variabel hanyalah nama yang merujuk ke objek. Untuk contoh di atas: “Doing y = x doesn’t create a copy of the list – it creates a new variable y that refers to the same object x refers to.” Hanya ada satu list di memori, dengan dua nama yang menunjuk ke sana.
>>> x = [1, 2, 3]
>>> y = x
>>> y.append(4)
>>> x
[1, 2, 3, 4]
>>> x is y
True
is memeriksa apakah dua nama menunjuk ke objek yang sama. Di sini jawabannya ya.
Lalu kenapa angka terlihat berbeda?
>>> n = 10
>>> m = n
>>> m = m + 1
>>> n, m
(10, 11)
Tidak ada yang aneh di sini, dan alasannya bukan karena angka “disalin”. m = m + 1 membuat objek angka baru (11) lalu mengarahkan m ke sana. n tetap menunjuk ke 10. Bedanya ada di antara mengubah sebuah objek (append mengubah list di tempatnya) dan mengarahkan nama ke objek lain (= dengan nilai baru).
Angka dan string di Python tidak bisa diubah di tempat (sifatnya immutable), jadi yang terjadi selalu jenis kedua. List, dictionary, dan kebanyakan objek bisa diubah di tempat (sifatnya mutable), jadi berbagi objek itu berarti berbagi perubahannya juga.
JavaScript sama untuk objek
const user = { name: "Rama" };
const other = user;
other.name = "Budi";
console.log(user.name); // Budi
const copy = { ...user };
copy.name = "Sari";
console.log(user.name, copy.name); // Budi Sari
other = user berbagi objek yang sama. { ...user } membuat objek baru dengan isi yang sama, jadi mengubah copy tidak menyentuh user.
PHP: array disalin, objek dipakai bersama
PHP adalah yang paling beda, dan kalau Anda terbiasa dengan PHP, ini penting diketahui sebelum pindah bahasa. Manualnya menyebut: “Array assignment always involves value copying. Use the reference operator to copy an array by reference.” Meng-assign array selalu menyalin isinya; untuk berbagi, pakai operator referensi &.
$a = [1, 2, 3];
$b = $a;
$b[] = 4;
echo json_encode($a), " ", json_encode($b); // [1,2,3] [1,2,3,4]
$c = &$a; // referensi eksplisit
$c[] = 99;
echo json_encode($a); // [1,2,3,99]
Jadi kode yang aman-aman saja di PHP ($b = $a; $b[] = 4;) justru ikut mengubah data aslinya kalau ditulis sama persis di Python atau JavaScript.
Objek berperilaku seperti di bahasa lain, dengan satu catatan kaki. Manualnya mengingatkan bahwa anggapan “objects are passed by reference by default” itu “not completely true”: variabel yang berisi objek “only contains an object identifier which allows object accessors to find the actual object”, hanya menyimpan pengenal untuk menemukan objeknya. Dalam praktiknya, dua variabel memakai objek yang sama, dan clone membuat objek terpisah:
$user = new stdClass();
$user->name = "Rama";
$other = $user;
$other->name = "Budi";
echo $user->name; // Budi
$copy = clone $user;
$copy->name = "Sari";
echo $user->name, " ", $copy->name; // Budi Sari
Go membuat bedanya terlihat jelas
Go berguna di sini karena punya kedua perilaku berdampingan. Artikel tentang slice di blog Go menyebut: “Go’s arrays are values. This means that when you assign or pass around an array value you will make a copy of its contents.” Array di Go adalah nilai, jadi ikut tersalin. Slice berbeda: “A slice is a descriptor of an array segment”, dan “Slicing does not copy the slice’s data.”
arr := [3]int{1, 2, 3}
arrCopy := arr
arrCopy[0] = 99
fmt.Println(arr, arrCopy) // [1 2 3] [99 2 3]
s := []int{1, 2, 3}
t := s
t[0] = 99
fmt.Println(s, t) // [99 2 3] [99 2 3]
u := make([]int, len(s))
copy(u, s)
u[1] = 42
fmt.Println(s, u) // [99 2 3] [99 42 3]
Array-nya tersalin, jadi mengubah arrCopy tidak menyentuh arr. Slice-nya ter-share, jadi mengubah t ikut mengubah s. Untuk mendapat slice yang benar-benar terpisah, salin secara eksplisit.
Shallow copy dan deep copy
Menyalin pun punya jebakannya sendiri. Dokumentasi modul copy di Python dibuka dengan: “Assignment statements in Python do not copy objects, they create bindings between a target and an object.” Saat kita memang butuh salinan, ada dua jenis:
- Shallow copy “constructs a new compound object and then (to the extent possible) inserts references into it to the objects found in the original”: wadah luarnya baru, isinya masih menunjuk ke objek lama.
- Deep copy “constructs a new compound object and then, recursively, inserts copies into it of the objects found in the original”: semuanya disalin sampai ke dalam.
Bedanya baru terlihat pada data bersarang:
>>> import copy
>>> a = [[1, 2], [3, 4]]
>>> s = copy.copy(a) # shallow
>>> d = copy.deepcopy(a) # deep
>>> a[0].append(99)
>>> s
[[1, 2, 99], [3, 4]]
>>> d
[[1, 2], [3, 4]]
Shallow copy adalah list luar yang baru, tapi list di dalamnya masih sama dengan milik a. Deep copy menyalin semuanya.
Jebakan klasik: default argument yang mutable
Tutorial Python punya “Important warning” khusus untuk ini: “The default value is evaluated only once.” Nilai default hanya dievaluasi sekali. Ini jadi masalah kalau default-nya “a mutable object such as a list, dictionary, or instances of most classes”:
def add_item(item, items=[]):
items.append(item)
return items
print(add_item("a")) # ['a']
print(add_item("b")) # ['a', 'b'] ← bukan ['b']
List kosong itu dibuat sekali saja, saat fungsi didefinisikan, dan setiap pemanggilan yang memakai default berbagi list yang sama. Perbaikan yang umum:
def add_item(item, items=None):
if items is None:
items = []
items.append(item)
return items
print(add_item("a")) # ['a']
print(add_item("b")) # ['b']
Stack, heap, dan siapa yang bersih-bersih
Ada dua istilah yang sering terdengar soal tempat data disimpan:
- Stack menyimpan data berumur pendek milik fungsi yang sedang berjalan: variabel lokalnya dan alamat untuk kembali. Otomatis dibersihkan saat fungsi selesai.
- Heap menyimpan data yang perlu bertahan lebih lama dari satu pemanggilan fungsi, seperti objek dan list yang dioper ke sana kemari.
Aturan pastinya berbeda tiap bahasa dan compiler, dan di Python, JavaScript, maupun Go kita jarang menentukannya sendiri. Yang perlu diketahui: memori heap harus dibebaskan suatu saat. Di bahasa seperti C, programmer membebaskannya manual. Di Python, JavaScript, dan Go, ada garbage collector yang mengerjakannya. MDN menggambarkannya untuk JavaScript: ia “automatically allocates memory when objects are created and frees it when they are not used anymore.”
“Tidak dipakai lagi” artinya tidak ada yang menunjuk ke sana. Dari situ pula memory leak terjadi di bahasa ber-garbage collector: ada sesuatu yang terlupa, misalnya cache, list global, atau event listener, yang masih memegang referensi, sehingga memorinya tidak pernah bisa dibebaskan.
Kenapa ini penting sehari-hari
- Perubahan tak terduga. Fungsi yang mengubah list atau objek yang diterimanya ikut mengubah milik pemanggilnya. Kalau bukan itu maksudnya, salin dulu atau kembalikan nilai baru.
- State di aplikasi front-end. Framework yang mendeteksi perubahan dengan membandingkan referensi (seperti React) tidak akan sadar kalau objek diubah di tempat. Karena itulah kita sering melihat
{ ...state, field: value }. - Default dan cache yang ter-share. Default yang mutable, list di level modul, dan cache dipakai bersama oleh siapa pun yang memakainya, kadang lintas request di server.
- Memory leak. Di bahasa ber-garbage collector, leak biasanya berasal dari referensi yang terlupa, bukan dari lupa memanggil
free.
Coba sendiri
- Jalankan contoh list
x/y, lalu gantiy = xmenjadiy = x.copy()dan jalankan lagi. - Jalankan contoh shallow vs deep copy dengan dictionary berisi list, bukan list berisi list.
- Di console browser, buat sebuah objek, simpan ke variabel kedua, ubah properti lewat variabel kedua, lalu tampilkan variabel pertama.
- Kalau Go sudah terpasang, tulis satu fungsi yang menerima array dan satu yang menerima slice, ubah elemen pertama di dalam masing-masing, lalu cetak data aslinya.
Ringkasan
- Variabel adalah nama yang menunjuk ke sesuatu di memori, bukan kotak yang menyimpannya.
- Memberikan objek mutable ke variabel lain berarti berbagi, bukan menyalin.
- Mengubah objek di tempat berbeda dengan mengarahkan nama ke objek baru.
- Array di Go dan array di PHP tersalin saat di-assign; slice di Go berbagi array di bawahnya; objek PHP dipakai bersama sampai di-
clone. - Shallow copy berbagi objek bersarang; deep copy menyalin semuanya.
- Python mengevaluasi nilai default argumen sekali saja, jadi jangan pakai default yang mutable.
- Garbage collector membebaskan memori yang tidak ditunjuk siapa pun; leak berasal dari referensi yang terlupa.
Referensi
- Programming FAQ: Why did changing list ‘y’ also change list ‘x’?, dokumentasi Python.
- More Control Flow Tools: Default Argument Values, tutorial Python.
- copy — Shallow and deep copy operations, dokumentasi Python.
- Memory management, MDN.
- Andrew Gerrand, Go Slices: usage and internals, The Go Blog, Januari 2011.
- Arrays dan Objects and references, PHP Manual.