Tipe Primitif JavaScript: Tujuh Jenis Nilai Bawaan

Tujuh primitif dan sisanya

JavaScript membagi nilai ke dalam dua kubu. Di satu sisi, tujuh tipe primitif: nilai yang sederhana dan tidak bisa diubah. Di sisi lain, object: semua yang tersusun dari bagian lain, bisa diubah, atau bisa dipanggil. Itulah seluruh sistem tipe di tingkat nilai.

Ketujuh primitif itu:

console.log(typeof "hello");     // string
console.log(typeof 42);          // number
console.log(typeof 42n);         // bigint
console.log(typeof true);        // boolean
console.log(typeof undefined);   // undefined
console.log(typeof Symbol("x")); // symbol
console.log(typeof null);        // object  ← historical bug

Apa pun yang tidak ada di daftar itu, seperti array, fungsi, tanggal, regex, dan {} biasa, adalah object. typeof memberimu tipe saat runtime, dan kamu pasti melihat cacat terkenal di baris terakhir. typeof null sudah mengembalikan 'object' sejak 1995 dan tidak akan pernah diperbaiki; terlalu banyak kode yang sudah bergantung padanya.

Primitif adalah nilai, bukan wadah

Cara berpikir yang paling membantu: primitif adalah nilainya sendiri. Angka 3 bukan kotak yang berisi 3; ia hanya 3. Dua variabel yang menyimpan 3 menyimpan nilai yang sama, bukan dua salinan yang menunjuk ke sesuatu yang dipakai bersama:

const a = 3;
const b = 3;

console.log(a === b);   // true - same value
console.log(a === 3);   // true

const x = { n: 3 };
const y = { n: 3 };

console.log(x === y);   // false - different objects

Primitif dibandingkan berdasarkan nilai. Object dibandingkan berdasarkan referensi. Perbedaan yang satu ini ada di balik banyak momen "kenapa ini false?" nantinya, terutama saat membandingkan array atau object dengan ===.

Primitif tidak bisa diubah

Kamu tidak bisa memodifikasi primitif. Setiap operasi yang terlihat seperti mengubah sebenarnya menghasilkan nilai baru:

let name = "ada";
name.toUpperCase();     // returns "ADA"
console.log(name);      // "ada" - unchanged

name = name.toUpperCase();
console.log(name);      // "ADA" - variable now points at a different string

Pemanggilan pertama membuat string baru lalu membuangnya karena tidak ada yang menangkap nilai kembaliannya. Yang kedua melakukan assignment ulang pada name. "ada" yang asli tidak pernah diubah, dan memang tidak bisa. Sama halnya dengan angka: x + 1 menghasilkan angka baru, bukan mengubah x.

Itulah kenapa const pada string atau angka benar-benar aman. Nilainya tidak bisa berubah, dan const mencegahmu melakukan assignment ulang pada variabelnya.

Number, BigInt, dan kenapa ada dua

number di JavaScript adalah float 64-bit. Artinya aritmetikanya cepat, tapi ada batas atas: bilangan bulat hanya tepat sampai Number.MAX_SAFE_INTEGER (2^53 - 1):

console.log(Number.MAX_SAFE_INTEGER);         // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER + 1);     // 9007199254740992
console.log(Number.MAX_SAFE_INTEGER + 2);     // 9007199254740992 ← wrong

Melewati ambang itu, bilangan bulat mulai bertabrakan. bigint ada untuk bilangan bulat yang harus tetap tepat berapa pun besarnya. Kamu menulisnya dengan akhiran n:

const big = 9007199254740993n;
console.log(big + 1n);          // 9007199254740994n

// console.log(big + 1);        // TypeError - can't mix bigint and number

bigint dan number tidak bisa dicampur dalam aritmetika, karena itu akan menghilangkan seluruh manfaat presisi tambahannya. Pakai bigint saat kamu berurusan dengan ID database, timestamp dalam nanodetik, atau kriptografi. Aritmetika biasa tetap memakai number.

String juga primitif

String di JavaScript adalah primitif, bukan object, walaupun ia menyediakan method seperti .length, .slice, .toUpperCase:

const greeting = "hello";

console.log(greeting.length);          // 5
console.log(greeting.toUpperCase());   // "HELLO"
console.log(typeof greeting);          // "string"

Di balik layar, saat kamu memanggil method pada string, JavaScript sebentar membungkusnya dalam object String supaya pemanggilan method berjalan, lalu membuang pembungkus itu. Kamu tidak perlu memikirkan pembungkus itu; cukup tahu bahwa string berperilaku seperti nilai (tidak bisa diubah, dibandingkan berdasarkan nilai) walaupun punya banyak method.

Tanda kutip tunggal, tanda kutip ganda, dan backtick semuanya membuat tipe yang sama. Backtick juga mendukung interpolasi dan string multi-baris, yang dibahas di dokumen berikutnya.

null vs undefined

Dua primitif berarti "tidak ada nilai", dan keduanya tidak bisa saling menggantikan.

undefined adalah yang kamu dapat saat sesuatu tidak pernah diberi nilai: variabel yang dideklarasikan tapi belum diisi, argumen fungsi yang tidak dikirim, property yang tidak ada:

let x;
console.log(x);               // undefined

function greet(name) {
    console.log(name);
}
greet();                      // undefined

const user = { name: "Rosa" };
console.log(user.email);      // undefined

null adalah yang kamu tulis saat ingin mengatakan "sengaja dikosongkan":

let selectedItem = null;      // nothing selected yet, but we meant to say so

selectedItem = { id: 42 };
console.log(selectedItem);

Kesepakatan kasarnya: undefined adalah cara bahasa mengatakan "tidak ada apa-apa di sini", null adalah cara programmer mengatakannya. Keduanya falsy, keduanya tidak sama dengan nilai biasa, dan keduanya punya halaman khusus nanti.

Symbol: unik sejak dibuat

symbol adalah primitif yang paling jarang dipakai. Setiap symbol yang kamu buat bersifat unik, bahkan kalau dua symbol dibuat dari deskripsi yang sama:

const a = Symbol("id");
const b = Symbol("id");

console.log(a === b);         // false
console.log(a.description);   // "id"

const user = {};
user[a] = "first value";
user[b] = "second value";

console.log(user[a]);         // "first value"
console.log(user[b]);         // "second value"

Symbol berguna sebagai key object yang tidak bisa bertabrakan dengan key yang sudah ada: sebuah library bisa menempelkan metadata ke object-mu memakai symbol dan yakin tidak ada kode lain yang akan menimpanya. Kamu akan bertemu symbol lagi saat membahas iterator dan well-known symbol seperti Symbol.iterator.

Mengecek tipe saat runtime

typeof menangani sebagian besar kasus. Ingat keanehan-keanehan ini:

console.log(typeof "abc");        // "string"
console.log(typeof 42);           // "number"
console.log(typeof 42n);          // "bigint"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof Symbol());     // "symbol"

console.log(typeof null);         // "object"   ← quirk
console.log(typeof [1, 2]);       // "object"
console.log(typeof function(){}); // "function" ← also quirk, but useful

Untuk null, bandingkan langsung: value === null. Untuk array, pakai Array.isArray(value). Untuk "apakah ini primitif apa saja?" tidak ada satu fungsi bawaan, tapi idiomnya cukup jelas:

function isPrimitive(value) {
    return value === null || (typeof value !== "object" && typeof value !== "function");
}

console.log(isPrimitive("hello"));   // true
console.log(isPrimitive(42));        // true
console.log(isPrimitive(null));      // true
console.log(isPrimitive({}));        // false
console.log(isPrimitive([1, 2]));    // false

Primitif vs object: jebakan assignment

Satu hal lagi yang perlu kamu lihat sebelum lanjut. Karena primitif adalah nilai dan object adalah referensi, assignment berperilaku berbeda:

let a = 10;
let b = a;
b = 20;
console.log(a);          // 10 - unaffected

let x = { n: 10 };
let y = x;
y.n = 20;
console.log(x.n);        // 20 - same object

Pada primitif, b = a menyalin nilainya. Pada object, y = x menyalin referensinya: kedua nama menunjuk ke object yang sama. Mengubah lewat satu nama memengaruhi nama lainnya. Inilah sumber terbesar bug "lho, kenapa itu berubah?" di JavaScript.

Yang perlu kamu ingat

• Tujuh primitif: string, number, bigint, boolean, null, undefined, symbol. Selebihnya adalah object.
• Primitif tidak bisa diubah dan dibandingkan berdasarkan nilai; object bisa diubah dan dibandingkan berdasarkan referensi.
• typeof memberitahumu tipe saat runtime, dengan dua keanehan yang perlu dihafal: typeof null === "object" dan typeof function === "function".
• number adalah float 64-bit dengan batas aman untuk bilangan bulat; bigint ada untuk bilangan bulat yang tepat melewati batas itu.

Berikutnya: string dan template literal

String adalah primitif yang paling sering kamu sentuh, dan template literal (string dengan backtick itu) membuat penyusunannya mudah: interpolasi, teks multi-baris, tagged template. Itulah halaman berikutnya.