01 Nilai, Tipe, dan Operator

Bab 1 dari Eloquent JavaScript. Sebelumnya: 00 Pengenalan. Berikutnya: 02 Struktur Program.

Di bawah permukaan mesin, program bergerak. Tanpa usaha, dia mengembang dan mengerut. Dalam harmoni yang agung, elektron menyebar dan berkumpul lagi. Bentuk-bentuk di monitor cuma riak di atas air. Esensinya tetap tak terlihat di bawah.

— Master Yuan-Ma, The Book of Programming

Di dunia komputer, cuma ada data. Kamu bisa baca data, ngubah data, bikin data baru, tapi yang bukan data gak bisa disebut. Semua data ini disimpan sebagai deretan panjang bit dan karena itu pada dasarnya semuanya mirip.

Bit itu apa pun yang punya dua nilai, biasanya digambarkan sebagai nol dan satu. Di dalam komputer, mereka berbentuk kaya muatan listrik tinggi atau rendah, sinyal kuat atau lemah, atau titik mengkilap atau kusam di permukaan CD. Setiap potongan informasi diskrit bisa direduksi jadi deretan nol dan satu dan dengan begitu diwakili dalam bit.

Contohnya, kita bisa nyatain angka 13 dalam bit. Cara kerjanya sama kaya angka desimal, tapi bukannya 10 digit berbeda, kita cuma punya 2, dan bobot tiap digitnya naik dua kali lipat dari kanan ke kiri. Ini bit-bit yang nyusun angka 13, dengan bobot digitnya ditunjukin di bawahnya:

   0   0   0   0   1   1   0   1
 128  64  32  16   8   4   2   1

Itu angka biner 00001101. Digit-digit yang bukan nolnya mewakili 8, 4, dan 1, yang kalau dijumlah jadi 13.

Nilai (Values)

Bayangin lautan bit, samudera bit. Komputer modern biasa punya lebih dari 100 miliar bit di penyimpanan data volatile-nya (memori kerja). Penyimpanan nonvolatile (hard disk atau yang setara) biasanya punya beberapa orde besaran lebih banyak lagi.

Biar bisa kerja dengan bit sebanyak itu tanpa tersesat, kita misahin mereka jadi potongan-potongan yang mewakili potongan informasi. Di lingkungan JavaScript, potongan-potongan itu disebut nilai (values). Walaupun semua nilai terbuat dari bit, mereka mainin peran yang berbeda. Setiap nilai punya tipe yang nentuin perannya. Ada nilai yang berupa angka, ada yang berupa potongan teks, ada yang berupa fungsi, dan seterusnya.

Buat bikin nilai, kamu cukup manggil namanya. Ini praktis. Kamu gak perlu ngumpulin bahan bangunan buat nilai-nilaimu atau bayar buat mereka. Kamu tinggal minta satu, dan whoosh, kamu dapet. Tentu aja, nilai gak beneran dibikin dari udara kosong. Masing-masing harus disimpan di suatu tempat, dan kalau kamu mau pakai jumlah yang luar biasa banyak sekaligus, memori komputermu bisa habis. Untungnya, ini cuma jadi masalah kalau kamu butuh semuanya secara bersamaan. Begitu kamu gak pakai sebuah nilai lagi, dia bakal buyar, ninggalin bit-bitnya buat didaur ulang jadi bahan bangunan buat generasi nilai berikutnya.

Sisa bab ini ngenalin elemen-elemen atomik dari program JavaScript, yaitu tipe-tipe nilai sederhana dan operator-operator yang bisa bekerja pada nilai-nilai itu.

Angka (Numbers)

Nilai dengan tipe number itu, gak mengejutkan, nilai numerik. Di program JavaScript, mereka ditulis kaya gini:

13

Pakai itu di program bakal bikin pola bit buat angka 13 muncul di dalam memori komputer.

JavaScript pakai jumlah bit yang tetap, 64 bit, buat nyimpen satu nilai angka. Cuma ada sekian banyak pola yang bisa kamu bikin dengan 64 bit, yang ngebatasin jumlah angka berbeda yang bisa diwakili. Dengan N digit desimal, kamu bisa mewakili 10^N angka. Sama juga, dengan 64 digit biner, kamu bisa mewakili 2^64 angka berbeda, yang kira-kira 18 kuintiliun (18 diikuti 18 nol). Itu banyak.

Memori komputer dulu jauh lebih kecil, dan orang cenderung pakai kelompok 8 atau 16 bit buat mewakili angka mereka. Gampang banget gak sengaja overflow angka sekecil itu, alias dapet angka yang gak muat di jumlah bit yang tersedia. Sekarang, bahkan komputer yang muat di kantongmu punya memori berlimpah, jadi kamu bebas pakai potongan 64-bit, dan kamu cuma perlu khawatir soal overflow kalau nanganin angka yang beneran astronomis.

Tapi gak semua bilangan bulat yang kurang dari 18 kuintiliun muat di angka JavaScript. Bit-bit itu juga nyimpen angka negatif, jadi satu bit nunjukin tanda angkanya. Masalah yang lebih besar adalah mewakili angka yang bukan bilangan bulat. Buat ini, sebagian bit dipakai buat nyimpen posisi titik desimal. Bilangan bulat maksimum sebenarnya yang bisa disimpan lebih di kisaran 9 kuadriliun (15 nol), yang masih sangat besar.

Angka pecahan ditulis pakai titik:

9.81

Buat angka yang sangat besar atau sangat kecil, kamu juga bisa pakai notasi ilmiah dengan nambahin e (buat eksponen), diikuti eksponen angkanya.

2.998e8

Itu 2.998 × 10^8 = 299.800.000.

Perhitungan dengan bilangan bulat (juga disebut integer) yang lebih kecil dari 9 kuadriliun tadi dijamin selalu presisi. Sayangnya, perhitungan dengan angka pecahan umumnya gak. Sama kaya π (pi) yang gak bisa dinyatain secara presisi dengan jumlah digit desimal yang terbatas, banyak angka kehilangan sedikit presisi kalau cuma ada 64 bit buat nyimpennya. Ini sayang banget, tapi cuma bikin masalah praktis di situasi tertentu. Yang penting adalah sadar soal ini dan memperlakukan angka pecahan digital sebagai perkiraan, bukan nilai yang presisi.

Aritmetika

Hal utama yang dilakuin sama angka adalah aritmetika. Operasi aritmetika kaya penjumlahan atau perkalian ngambil dua nilai angka dan ngehasilin angka baru dari mereka. Ini bentuknya di JavaScript:

100 + 4 * 11

Simbol + dan * disebut operator. Yang pertama buat penjumlahan dan yang kedua buat perkalian. Naruh operator di antara dua nilai bakal nerapin operator itu ke nilai-nilai tersebut dan ngehasilin nilai baru.

Apakah contoh ini artinya “Tambahkan 4 dan 100, lalu kalikan hasilnya dengan 11”, atau perkaliannya dilakuin sebelum penjumlahan? Kaya yang mungkin udah kamu tebak, perkalian terjadi duluan. Kaya di matematika, kamu bisa ngubah ini dengan ngebungkus penjumlahannya pakai tanda kurung.

(100 + 4) * 11

Buat pengurangan, ada operator -. Pembagian bisa dilakuin dengan operator /.

Kalau operator muncul bareng tanpa tanda kurung, urutan penerapannya ditentuin sama precedence (prioritas) operatornya. Contoh tadi nunjukin perkalian didahuluin sebelum penjumlahan. Operator / punya prioritas yang sama dengan *. Begitu juga + dan - punya prioritas yang sama. Kalau beberapa operator dengan prioritas sama muncul bersebelahan, kaya di 1 - 2 + 1, mereka diterapin dari kiri ke kanan: (1 - 2) + 1.

Jangan terlalu khawatir soal aturan prioritas ini. Kalau ragu, tambahin aja tanda kurung.

Ada satu lagi operator aritmetika yang mungkin gak langsung kamu kenali. Simbol % dipakai buat mewakili operasi sisa bagi (remainder). X % Y adalah sisa dari pembagian X dengan Y. Contohnya, 314 % 100 ngehasilin 14, dan 144 % 12 ngasih 0. Prioritas operator sisa bagi sama dengan perkalian dan pembagian. Kamu juga bakal sering lihat operator ini disebut modulo.

Angka Spesial

Ada tiga nilai spesial di JavaScript yang dianggap angka tapi gak berperilaku kaya angka normal. Dua yang pertama adalah Infinity dan -Infinity, yang mewakili tak hingga positif dan negatif. Infinity - 1 tetap Infinity, dan seterusnya. Tapi jangan terlalu percaya sama perhitungan berbasis tak hingga. Secara matematis dia gak sehat, dan bakal cepat ngarah ke angka spesial berikutnya: NaN.

NaN singkatan dari “not a number” (bukan angka), walaupun dia adalah nilai bertipe number. Kamu bakal dapet hasil ini kalau, misalnya, nyoba ngitung 0 / 0 (nol dibagi nol), Infinity - Infinity, atau berbagai operasi numerik lain yang gak ngehasilin hasil yang bermakna.

String

Tipe data dasar berikutnya adalah string. String dipakai buat mewakili teks. Mereka ditulis dengan ngebungkus isinya dalam tanda kutip.

`Down on the sea`
"Lie on the ocean"
'Float on the ocean'

Kamu bisa pakai kutip tunggal, kutip ganda, atau backtick buat nandain string, selama kutip di awal dan akhir stringnya cocok.

Kamu bisa naruh hampir apa pun di antara tanda kutip biar JavaScript bikin nilai string dari itu. Tapi beberapa karakter lebih susah. Bisa kamu bayangin naruh tanda kutip di antara tanda kutip itu susah, karena mereka bakal keliatan kaya akhir string. Newline (karakter yang kamu dapet waktu mencet enter) cuma bisa dimasukin kalau stringnya dikutip pakai backtick (```).

Biar bisa masukin karakter kaya gitu ke dalam string, notasi berikut dipakai: backslash (\) di dalam teks yang dikutip nunjukin bahwa karakter setelahnya punya makna khusus. Ini disebut escaping karakter. Tanda kutip yang didahului backslash gak bakal ngakhirin string tapi jadi bagian dari string itu. Kalau karakter n muncul setelah backslash, dia ditafsirin sebagai newline. Sama juga, t setelah backslash artinya karakter tab. Lihat string berikut:

"This is the first line\nAnd this is the second"

Ini teks sebenarnya di string itu:

This is the first line
And this is the second

Tentu aja, ada situasi di mana kamu mau backslash di string itu cuma jadi backslash biasa, bukan kode khusus. Kalau dua backslash berurutan, mereka bakal melebur, dan cuma satu yang tersisa di nilai string hasilnya. Ini cara string “A newline character is written like "\n".” bisa dinyatain:

"A newline character is written like \"\\n\"."

String juga harus dimodelkan sebagai deretan bit biar bisa ada di dalam komputer. Cara JavaScript ngelakuin ini didasarkan pada standar Unicode. Standar ini ngasih angka ke hampir setiap karakter yang mungkin kamu butuhin, termasuk karakter dari Yunani, Arab, Jepang, Armenia, dan seterusnya. Kalau kita punya angka buat setiap karakter, string bisa digambarin sebagai deretan angka. Dan itulah yang dilakuin JavaScript.

Tapi ada komplikasinya: representasi JavaScript pakai 16 bit per elemen string, yang bisa menggambarkan sampai 2^16 karakter berbeda. Tapi Unicode mendefinisikan lebih banyak karakter dari itu, kira-kira dua kali lipatnya saat ini. Jadi beberapa karakter, kaya banyak emoji, makan dua “posisi karakter” di string JavaScript. Kita bakal balik ke ini di Bab 5.

String gak bisa dibagi, dikali, atau dikurangi. Operator + bisa dipakai ke mereka, bukan buat nambah, tapi buat concatenate, alias ngelem dua string jadi satu. Baris berikut bakal ngehasilin string "concatenate":

"con" + "cat" + "e" + "nate"

Nilai string punya sejumlah fungsi terkait (method) yang bisa dipakai buat ngelakuin operasi lain ke mereka. Saya bakal cerita lebih banyak soal ini di Bab 4.

String yang ditulis pakai kutip tunggal atau ganda berperilaku hampir sama, satu-satunya perbedaan ada di tipe kutip mana yang perlu kamu escape di dalamnya. String berkutip backtick, biasanya disebut template literal, bisa ngelakuin beberapa trik lagi. Selain bisa membentang beberapa baris, mereka juga bisa nyisipin nilai lain.

`half of 100 is ${100 / 2}`

Kalau kamu nulis sesuatu di dalam ${} di template literal, hasilnya bakal dihitung, dikonversi jadi string, dan disisipin di posisi itu. Contoh ini ngehasilin string "half of 100 is 50".

Operator Unary

Gak semua operator itu simbol. Ada yang ditulis sebagai kata. Salah satu contohnya operator typeof, yang ngehasilin nilai string yang nyebutin tipe dari nilai yang kamu kasih ke dia.

console.log(typeof 4.5)
// → number
console.log(typeof "x")
// → string

Kita bakal pakai console.log di kode contoh buat nunjukin bahwa kita mau lihat hasil evaluasi sesuatu. (Lebih lanjut soal itu di bab berikutnya.)

Operator-operator lain yang udah ditunjukin sejauh ini di bab ini semuanya bekerja pada dua nilai, tapi typeof cuma ngambil satu. Operator yang pakai dua nilai disebut operator binary, sedangkan yang ngambil satu disebut operator unary. Operator minus (-) bisa dipakai sebagai operator binary maupun operator unary.

console.log(- (10 - 2))
// → -8

Nilai Boolean

Sering kali berguna punya nilai yang cuma ngebedain dua kemungkinan, kaya “ya” dan “tidak” atau “nyala” dan “mati”. Buat tujuan ini, JavaScript punya tipe Boolean, yang cuma punya dua nilai, true dan false, ditulis dengan kata-kata itu.

Perbandingan

Ini salah satu cara ngehasilin nilai Boolean:

console.log(3 > 2)
// → true
console.log(3 < 2)
// → false

Tanda > dan < adalah simbol tradisional buat “lebih besar dari” dan “lebih kecil dari”. Mereka operator binary. Nerapin mereka ngehasilin nilai Boolean yang nunjukin apakah pernyataannya benar dalam kasus itu.

String bisa dibandingin dengan cara yang sama.

console.log("Aardvark" < "Zoroaster")
// → true

Cara string diurutkan kurang lebih alfabetis tapi gak persis kaya yang kamu harapkan di kamus: huruf besar selalu “lebih kecil” dari huruf kecil, jadi "Z" < "a", dan karakter nonalfabet (!, -, dan seterusnya) juga ikut dalam pengurutan. Waktu ngebandingin string, JavaScript ngelewatin karakternya dari kiri ke kanan, ngebandingin kode Unicode-nya satu per satu.

Operator serupa lainnya adalah >= (lebih besar atau sama dengan), <= (lebih kecil atau sama dengan), == (sama dengan), dan != (tidak sama dengan).

console.log("Garnet" != "Ruby")
// → true
console.log("Pearl" == "Amethyst")
// → false

Cuma ada satu nilai di JavaScript yang gak sama dengan dirinya sendiri, yaitu NaN (“not a number”).

console.log(NaN == NaN)
// → false

NaN dimaksudkan buat nunjukin hasil dari perhitungan yang gak masuk akal, dan karena itu, dia gak sama dengan hasil dari perhitungan gak masuk akal lainnya.

Operator Logika

Ada juga beberapa operasi yang bisa diterapin ke nilai Boolean itu sendiri. JavaScript mendukung tiga operator logika: and, or, dan not. Ini bisa dipakai buat “bernalar” soal Boolean.

Operator && mewakili and logis. Dia operator binary, dan hasilnya true cuma kalau kedua nilai yang dikasih ke dia true.

console.log(true && false)
// → false
console.log(true && true)
// → true

Operator || nunjukin or logis. Dia ngehasilin true kalau salah satu dari nilai yang dikasih ke dia true.

console.log(false || true)
// → true
console.log(false || false)
// → false

Not ditulis sebagai tanda seru (!). Dia operator unary yang ngebalik nilai yang dikasih ke dia, !true ngehasilin false dan !false ngasih true.

Waktu nyampur operator Boolean ini sama aritmetika dan operator lain, gak selalu jelas kapan tanda kurung dibutuhin. Dalam praktik, biasanya kamu cukup tahu bahwa dari operator yang udah kita lihat sejauh ini, || punya prioritas paling rendah, lalu &&, lalu operator perbandingan (>, ==, dan seterusnya), lalu sisanya. Urutan ini dipilih supaya, di ekspresi tipikal kaya di bawah ini, tanda kurung yang dibutuhin sesedikit mungkin:

1 + 1 == 2 && 10 * 10 > 50

Operator logika terakhir yang kita lihat bukan unary, bukan binary, tapi ternary, bekerja pada tiga nilai. Dia ditulis pakai tanda tanya dan titik dua, kaya gini:

console.log(true ? 1 : 2);
// → 1
console.log(false ? 1 : 2);
// → 2

Yang ini disebut operator conditional (atau kadang cuma operator ternary karena dia satu-satunya operator kaya gitu di bahasa ini). Operator ini pakai nilai di sebelah kiri tanda tanya buat mutusin mana dari dua nilai lainnya yang “dipilih”. Kalau kamu nulis a ? b : c, hasilnya b kalau a true dan c kalau sebaliknya.

Nilai Kosong

Ada dua nilai spesial, ditulis null dan undefined, yang dipakai buat nunjukin ketiadaan nilai yang bermakna. Mereka sendiri adalah nilai, tapi gak bawa informasi apa pun.

Banyak operasi di bahasa ini yang gak ngehasilin nilai bermakna ngasih undefined semata-mata karena mereka harus ngasih suatu nilai.

Perbedaan makna antara undefined dan null itu kecelakaan dari desain JavaScript, dan kebanyakan waktu gak penting. Di kasus di mana kamu beneran harus peduli sama nilai-nilai ini, saya nyaranin memperlakukan mereka sebagai sesuatu yang bisa saling menggantikan.

Konversi Tipe Otomatis

Di pengenalan, saya nyebutin bahwa JavaScript berusaha keras buat nerima hampir semua program yang kamu kasih, bahkan program yang ngelakuin hal aneh. Ini ditunjukin dengan bagus sama ekspresi-ekspresi berikut:

console.log(8 * null)
// → 0
console.log("5" - 1)
// → 4
console.log("5" + 1)
// → 51
console.log("five" * 2)
// → NaN
console.log(false == 0)
// → true

Kalau operator diterapin ke nilai dengan tipe yang “salah”, JavaScript bakal diam-diam ngonversi nilai itu ke tipe yang dia butuhin, pakai sekumpulan aturan yang sering kali bukan yang kamu mau atau harapkan. Ini disebut type coercion. null di ekspresi pertama jadi 0 dan "5" di ekspresi kedua jadi 5 (dari string ke angka). Tapi di ekspresi ketiga, + nyoba penggabungan string sebelum penjumlahan numerik, jadi 1-nya dikonversi jadi "1" (dari angka ke string).

Kalau sesuatu yang gak jelas petanya ke angka (kaya "five" atau undefined) dikonversi ke angka, kamu dapet nilai NaN. Operasi aritmetika lanjutan ke NaN bakal terus ngehasilin NaN, jadi kalau kamu dapet salah satu dari itu di tempat yang gak terduga, cari konversi tipe yang gak sengaja.

Waktu ngebandingin nilai dengan tipe yang sama pakai operator ==, hasilnya gampang ditebak: kamu harusnya dapet true kalau kedua nilainya sama, kecuali di kasus NaN. Tapi kalau tipenya beda, JavaScript pakai sekumpulan aturan yang rumit dan membingungkan buat nentuin apa yang harus dilakuin. Di kebanyakan kasus, dia cuma nyoba ngonversi salah satu nilai ke tipe nilai lainnya. Tapi, kalau null atau undefined muncul di salah satu sisi operator, hasilnya true cuma kalau kedua sisinya adalah salah satu dari null atau undefined.

console.log(null == undefined);
// → true
console.log(null == 0);
// → false

Perilaku itu sering berguna. Kalau kamu mau ngetes apakah sebuah nilai punya nilai beneran bukannya null atau undefined, kamu bisa ngebandinginnya sama null pakai operator == atau !=.

Gimana kalau kamu mau ngetes apakah sesuatu nunjuk ke nilai false yang persis? Ekspresi kaya 0 == false dan "" == false juga true karena konversi tipe otomatis. Kalau kamu gak mau ada konversi tipe apa pun, ada dua operator tambahan: === dan !==. Yang pertama ngetes apakah sebuah nilai persis sama dengan yang lain, dan yang kedua ngetes apakah dia gak persis sama. Jadi "" === false hasilnya false, sesuai harapan.

Saya nyaranin pakai operator perbandingan tiga karakter secara defensif buat mencegah konversi tipe yang gak terduga bikin kamu terpeleset. Tapi kalau kamu yakin tipe di kedua sisi bakal sama, gak masalah pakai operator yang lebih pendek.

❌ rawan, == bikin konversi tipe diam-diam

console.log(0 == false)
// → true
console.log("" == false)
// → true

✅ aman, === gak ngonversi apa pun

console.log(0 === false)
// → false
console.log("" === false)
// → false

Short-Circuit pada Operator Logika

Operator logika && dan || nanganin nilai dengan tipe berbeda dengan cara yang unik. Mereka bakal ngonversi nilai di sisi kirinya ke tipe Boolean buat mutusin harus ngapain, tapi tergantung operatornya dan hasil konversi itu, mereka bakal ngembaliin nilai sisi kiri yang asli atau nilai sisi kanan.

Operator ||, misalnya, bakal ngembaliin nilai di kirinya kalau nilai itu bisa dikonversi jadi true dan ngembaliin nilai di kanannya kalau sebaliknya. Ini punya efek yang diharapkan waktu nilainya Boolean dan ngelakuin sesuatu yang analog buat nilai tipe lain.

console.log(null || "user")
// → user
console.log("Agnes" || "user")
// → Agnes

Kita bisa pakai fungsi ini sebagai cara buat balik ke nilai default. Kalau kamu punya nilai yang mungkin kosong, kamu bisa naruh || setelahnya dengan nilai pengganti. Kalau nilai awalnya bisa dikonversi jadi false, kamu bakal dapet penggantinya. Aturan buat ngonversi string dan angka ke nilai Boolean nyatain bahwa 0, NaN, dan string kosong ("") dihitung sebagai false, sedangkan semua nilai lain dihitung sebagai true. Itu artinya 0 || -1 ngehasilin -1, dan "" || "!?" ngasih "!?".

Operator ?? mirip || tapi ngembaliin nilai di kanan cuma kalau yang di kiri itu null atau undefined, bukan kalau dia nilai lain yang bisa dikonversi jadi false. Sering kali, ini lebih disukai daripada perilaku ||.

console.log(0 || 100);
// → 100
console.log(0 ?? 100);
// → 0
console.log(null ?? 100);
// → 100

Operator && bekerja serupa tapi kebalikannya. Kalau nilai di kirinya sesuatu yang dikonversi jadi false, dia ngembaliin nilai itu, dan kalau sebaliknya dia ngembaliin nilai di kanannya.

Sifat penting lain dari dua operator ini adalah bagian di kanannya cuma dievaluasi kalau perlu. Di kasus true || X, apa pun X-nya, bahkan kalau itu potongan program yang ngelakuin sesuatu yang mengerikan, hasilnya bakal true, dan X gak pernah dievaluasi. Sama juga buat false && X, yang false dan bakal ngabaikan X. Ini disebut short-circuit evaluation.

Operator conditional bekerja dengan cara serupa. Dari nilai kedua dan ketiga, cuma yang terpilih yang dievaluasi.

Ringkasan

Kita ngelihat empat tipe nilai JavaScript di bab ini: angka, string, Boolean, dan nilai undefined. Nilai-nilai kaya gitu dibikin dengan ngetik namanya (true, null) atau nilainya (13, "abc").

Kamu bisa ngegabungin dan ngubah nilai pakai operator. Kita lihat operator binary buat aritmetika (+, -, *, /, dan %), penggabungan string (+), perbandingan (==, !=, ===, !==, <, >, <=, >=), dan logika (&&, ||, ??), juga beberapa operator unary (- buat negasi angka, ! buat negasi logis, dan typeof buat nyari tipe sebuah nilai) dan operator ternary (?:) buat milih satu dari dua nilai berdasarkan nilai ketiga.

Ini ngasih kamu cukup informasi buat pakai JavaScript sebagai kalkulator saku tapi gak lebih dari itu. Bab berikutnya bakal mulai ngerangkai ekspresi-ekspresi ini jadi program dasar.

Poin-poin pentingnya:

1. Semua data di komputer itu bit; JavaScript ngelompokin bit jadi nilai yang punya tipe.
2. Angka disimpan dalam 64 bit. Bilangan bulat di bawah 9 kuadriliun selalu presisi, angka pecahan itu perkiraan. Ada Infinity, -Infinity, dan NaN (yang gak sama dengan dirinya sendiri).
3. String bisa pakai ', ", atau backtick. Backtick (template literal) bisa multi-baris dan nyisipin nilai lewat ${}. Backslash buat escape karakter khusus.
4. Boolean cuma true/false, dihasilin dari perbandingan (<, >, ==, ===, dll) dan diolah pakai &&, ||, !, serta operator ternary ? :.
5. null dan undefined sama-sama berarti “gak ada nilai bermakna”, dan null == undefined itu true.
6. JavaScript ngonversi tipe secara otomatis (type coercion). Pakai === dan !== biar gak kejebak.
7. || dan && itu short-circuit: ngembaliin salah satu operand aslinya dan gak ngevaluasi sisi kanan kalau gak perlu. ?? cuma jatuh ke default kalau kirinya null/undefined.