Primitive Types

Data dalam sebuah program datang dengan bentuk yang beragam. Pada kedai kopi milik Budi, nama pelanggan berupa teks seperti "Budi", harga secangkir kopi berupa angka seperti 18000, status langganan berupa nilai benar-salah, dan ada catatan pesanan yang sama sekali belum terisi. JavaScript menyimpan setiap nilai itu dengan sebuah tipe, dan tipe inilah yang menentukan operasi mana yang sah untuk nilai tersebut: teks bisa digabungkan, angka bisa dijumlahkan, dan perbandingan menghasilkan keputusan.

Chapter ini memetakan tujuh tipe primitive JavaScript — fondasi dari semua nilai yang akan kita temui — lalu membuktikan dua sifat pentingnya. Pertama, primitive dibandingkan lewat isinya. Kedua, primitive bersifat immutable: isinya tidak bisa diubah sebagian. Kita menguji kedua sifat itu lewat satu berkas contoh di Node; operator typeof untuk memeriksa tipe kita bedah tuntas di chapter ketujuh section ini.

Tujuh Tipe Primitive #

JavaScript mengenali tujuh tipe nilai yang disebut primitive (nilai dasar). Ketujuhnya adalah unit terkecil pembentuk data; nilai yang lebih rumit dibangun di atasnya. Tabel berikut merangkum ketujuh tipe beserta contoh dan kegunaannya:

Setiap nilai di luar ketujuh tipe ini termasuk object — mulai dari array, object, hingga function. Karena object berperilaku berbeda dari primitive pada beberapa titik penting, perbatasan keduanya perlu dipahami sejak awal; pembahasan penuhnya menunggu kita di section Arrays dan section Objects.

Di balik layar, engine menyimpan nilai primitive secara langsung: ketika variabel menampung 18000, wadah variabel itu memegang nilai angkanya sendiri, bukan penunjuk ke lokasi penyimpanan lain. Model sederhana ini berdampak langsung pada dua perilaku yang kita buktikan berikutnya.

Dibandingkan Lewat Isinya #

Operator === membandingkan dua nilai primitive berdasarkan isinya. Dua string yang huruf-hurufnya sama dianggap sama, tidak peduli masing-masing diketik terpisah di baris yang berbeda:

console.log("Budi" === "Budi"); // true — isinya identik
console.log(18000 === 18000);   // true — angkanya identik

Output yang Dihasilkan:

true
true

Engine tidak tertarik dari mana setiap nilai berasal; engine hanya memeriksa isi kedua sisi. Perilaku ini terasa wajar dan hampir selalu sesuai harapan. Bandingkan nanti dengan object, yang dibandingkan berdasarkan identitas lokasi penyimpanan — perbedaan yang sering mengejutkan pemula dan kita bahas tuntas di section Objects.

Immutable: Tidak Bisa Diubah Sebagian #

Sifat kedua: nilai primitive tidak bisa diubah sebagian (immutable). Ketika kita “mengubah” string, yang sebenarnya terjadi adalah engine membuat string baru, lalu variabel menunjuk ke string baru itu. String lama tetap ada apa adanya. Konsekuensinya, percobaan menukar satu huruf di dalam string tidak berdampak apa-apa:

let sapaan = "selamat pagi";
sapaan[0] = "S"; // percobaan mengganti huruf pertama
console.log(sapaan);

Output yang Dihasilkan:

selamat pagi

Baris kedua tidak menghasilkan error dalam mode santai, tetapi juga tidak mengubah apa pun: string "selamat pagi" tetap dimulai huruf kecil. Engine mengabaikan percobaan penulisan itu secara diam-diam, dan inilah salah satu jebakan paling licik bagi pemula karena tidak ada pesan yang mengingatkan.

Cara yang benar untuk “mengubah” string adalah membuat string baru, misalnya lewat method bawaan seperti toUpperCase() atau replace(). Method-method itu kita latih leluasa di chapter berikutnya.

Contoh Lengkap: Membuktikan Sifat Primitive #

Berkas berikut merangkum kedua sifat primitive dalam satu uji: perbandingan lewat isi, penyalinan yang berdiri sendiri, percobaan pengubahan sebagian, dan method yang menghasilkan nilai baru:

// jenis-nilai.js
// Membuktikan dua sifat tipe primitive: dibandingkan lewat nilai, dan immutable.

// --- Nilai yang sama, dua wadah berbeda ---
let namaPertama = "Budi";
let namaKedua = "Budi";
console.log(namaPertama === namaKedua); // true

// --- Menyalin nilai primitive: tiap wadah berdiri sendiri ---
let skorPertama = 10;
let skorKedua = skorPertama; // nilai 10 disalin ke wadah baru
skorPertama = 20;            // wadah pertama diisi nilai baru
console.log(skorKedua);      // 10 — salinan tidak ikut berubah
console.log(skorPertama);    // 20

// --- String bersifat immutable: isinya tidak bisa ditukar sebagian ---
let sapaan = "selamat pagi";
sapaan[0] = "S"; // percobaan mengganti huruf pertama
console.log(sapaan); // tetap "selamat pagi", tanpa error

// --- Method string membuat string baru; string aslinya tetap utuh ---
const email = "[email protected]";
console.log(email.toUpperCase()); // [email protected]
console.log(email);               // [email protected]

Output yang Dihasilkan:

true
10
20
selamat pagi
[email protected]
[email protected]

Mari kita telaah apa yang terjadi pada baris-baris kode di atas:

1. Baris 5–6 (let namaPertama = "Budi"; dst.): dua variabel dibuat terpisah dan masing-masing memegang string milik sendiri. Keduanya tidak berbagi satu nilai yang sama.
2. Baris 7 (console.log(namaPertama === namaKedua);): hasilnya tetap true, karena === membandingkan isi kedua string, bukan asal-usulnya.
3. Baris 10–12 (let skorPertama = 10; dst.): nilai 10 disalin dari skorPertama ke skorKedua, lalu skorPertama diisi nilai baru 20. Penyalinan primitive menghasilkan dua nilai yang berdiri sendiri.
4. Baris 13–14 (console.log(skorKedua); dst.): keluaran 10 membuktikan salinan tidak ikut berubah, dan keluaran 20 membuktikan wadah pertama memang berganti nilai. Tidak ada keterkaitan tersembunyi antara keduanya.
5. Baris 17–18 (let sapaan = "selamat pagi"; lalu sapaan[0] = "S";): indeks [0] menunjuk huruf pertama string, tetapi string primitive tidak dapat ditulis sebagian. Percobaan penulisan itu diabaikan.
6. Baris 19 (console.log(sapaan);): keluaran selamat pagi dengan huruf kecil membuktikan string asli utuh — inilah immutable.
7. Baris 22–24 (const email = ... dst.): toUpperCase() menghasilkan string baru berhuruf kapital, sementara email sendiri tetap menunjuk string aslinya. Method tidak pernah mengubah string yang memanggilnya.

Dengan dua sifat ini — perbandingan lewat isi dan immutable — perilaku semua tipe primitive kini punya landasan. Section ini selanjutnya menelaah tipe-tipe itu satu per satu, dimulai dari tipe yang paling sering kita pegang: string.

// jenis-nilai.js
// Membuktikan dua sifat tipe primitive: dibandingkan lewat nilai, dan immutable.

// --- Nilai yang sama, dua wadah berbeda ---
let namaPertama = "Budi";
let namaKedua = "Budi";
console.log(namaPertama === namaKedua); // true

// --- Menyalin nilai primitive: tiap wadah berdiri sendiri ---
let skorPertama = 10;
let skorKedua = skorPertama; // nilai 10 disalin ke wadah baru
skorPertama = 20;            // wadah pertama diisi nilai baru
console.log(skorKedua);      // 10 — salinan tidak ikut berubah
console.log(skorPertama);    // 20

// --- String bersifat immutable: isinya tidak bisa ditukar sebagian ---
let sapaan = "selamat pagi";
sapaan[0] = "S"; // percobaan mengganti huruf pertama
console.log(sapaan); // tetap "selamat pagi", tanpa error

// --- Method string membuat string baru; string aslinya tetap utuh ---
const email = "[email protected]";
console.log(email.toUpperCase()); // [email protected]
console.log(email);               // [email protected]