1. Beranda
  2. JavaScript
  3. Tutorial Coding

JavaScript Equality Operators: Kapan Pakai ==, ===, dan Object.is()

4 Mei 2026

Pernahkah kamu merasa bingung kenapa sebuah kondisi if di JavaScript berjalan tidak sesuai keinginan? Atau mungkin kamu sedang melakukan debugging berjam-jam hanya untuk menemukan bahwa masalahnya ada pada satu karakter tambahan di operator perbandingan? Kalau iya, tenang, kamu tidak sendirian.

Dalam dunia JavaScript, perbandingan adalah jantung dari logika aplikasi. Namun, ada jebakan batman yang sering membuat pengembang pemula maupun senior terkecoh, yaitu perbedaan antara operator kesamaan longgar (==) dan operator kesamaan ketat (===). Memahami perbedaan ini bukan sekadar soal teori, tapi soal menulis kode yang robust, mudah dipelihara, dan bebas dari bug yang sulit dilacak.

1. Berkenalan dengan == dan ===

Sebelum kita masuk ke teknis yang lebih dalam, mari kita definisikan keduanya dengan bahasa yang santai. Di JavaScript, kita punya dua cara utama untuk membandingkan apakah dua nilai itu "sama".

  • Double Equals (==): Sering disebut sebagai Loose Equality atau Abstract Equality. Operator ini bekerja dengan cara yang agak "santai". Jika tipe datanya berbeda, dia akan mencoba mengubah salah satunya agar setara sebelum dibandingkan.
  • Triple Equals (===): Sering disebut sebagai Strict Equality atau Identity Operator. Operator ini sangat disiplin. Dia tidak akan memberikan toleransi; jika tipe datanya beda, maka hasilnya langsung false.

Bayangkan kamu sedang masuk ke sebuah klub malam. Operator == itu seperti penjaga pintu yang memperbolehkan kamu masuk asal kamu punya tiket, tidak peduli apakah tiket itu berbentuk kertas asli atau cuma foto di HP. Sedangkan === adalah penjaga pintu yang hanya mau menerima tiket fisik asli dengan stempel resmi; kalau bentuknya beda, kamu ditolak.

2. Mekanisme Type Coercion di Balik Operator ==

Kenapa == bisa dibilang longgar? Jawabannya adalah Type Coercion. Ini adalah proses otomatis di mana JavaScript mengubah tipe data secara implisit di balik layar.

Mari kita lihat contoh sederhana ini:

console.log(5 == "5"); // Hasilnya: true
console.log(5 === "5"); // Hasilnya: false

Pada baris pertama, JavaScript melihat ada angka 5 dan string 5. Karena kamu menggunakan ==, mesin JS berkata, Eh, ini beda jenis, tapi nilainya mirip. Coba deh aku ubah stringnya jadi angka dulu. Setelah diubah, barulah dibandingkan, dan hasilnya menjadi true.

Sedangkan pada baris kedua dengan ===, JS langsung melihat tipe datanya. Satu Number, satu String. Tanpa pikir panjang, dia langsung mengembalikan false. Inilah yang membuat === jauh lebih bisa diprediksi.

Contoh Gotcha yang Terkenal

Ada satu contoh klasik yang sering jadi meme di komunitas JavaScript:

console.log([] == ![]); // Hasilnya: true (!)

Kenapa bisa true? Mari kita uraikan langkah demi langkah:

  1. ![] dievaluasi terlebih dahulu. Array kosong adalah truthy, jadi ![] menjadi false.
  2. Sekarang perbandingannya menjadi [] == false.
  3. Array kosong [] di-coerce menjadi string kosong "".
  4. String kosong "" di-coerce menjadi angka 0.
  5. false juga di-coerce menjadi angka 0.
  6. Akhirnya: 0 == 0 → true.

Ini adalah contoh sempurna kenapa == bisa sangat membingungkan dan sulit ditebak.

3. Aturan Main di Abstract Equality (==)

Banyak orang benci dengan == karena aturannya terkadang terasa tidak masuk akal. Namun, sebenarnya ada spesifikasi resmi dari ECMAScript (aturan dasar JS) yang mengatur ini. Berikut beberapa skenario unik yang sering muncul:

Perbandingan dengan Boolean

Ini adalah jebakan yang paling umum. Kamu mungkin berpikir bahwa nilai apapun yang "ada isinya" akan sama dengan true. Ternyata tidak selalu begitu dalam konteks ==.

console.log("1" == true); // true (String "1" diubah jadi angka 1, true diubah jadi angka 1)
console.log("0" == false); // true
console.log("true" == true); // false! (Kenapa? Karena string "true" diubah jadi NaN saat jadi angka)

Null dan Undefined

Ada pengecualian khusus untuk null dan undefined. Di bawah operator ==, mereka berdua dianggap sama satu sama lain, tapi tidak sama dengan nilai lainnya. Ini adalah satu-satunya pasangan di mana == mengembalikan true meski tipe berbeda, dan ini sengaja dirancang demikian dalam spesifikasi ECMAScript.

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

4. Mengapa Kamu Harus Selalu Menggunakan ===?

Setelah melihat betapa membingungkannya ==, kamu mungkin bertanya-tanya: Kalau begitu, kenapa == masih ada? Jawabannya adalah sejarah dan beberapa kasus penggunaan khusus. Tapi untuk standar industri saat ini, penggunaan === adalah kewajiban tidak tertulis.

Alasan Keamanan dan Prediktabilitas

Dengan ===, kamu memastikan bahwa data yang masuk ke logika bisnismu benar-benar sesuai tipenya. Jika kamu mengharapkan angka dari input pengguna tapi mendapatkan string, === akan memberi tahu kamu bahwa ada yang salah. Ini mencegah kesalahan perhitungan di tahap selanjutnya.

Performa Mesin JavaScript

Meskipun perbedaan performanya tidak signifikan di aplikasi nyata, === tetap lebih direkomendasikan karena prediktabilitasnya. Mesin JavaScript tidak perlu melakukan langkah ekstra untuk mengubah tipe data (coercion) — dia hanya perlu cek tipe, kalau beda, selesai.

5. Perbandingan Objek dan Array: Jebakan Lainnya

Penting untuk kamu ingat bahwa baik == maupun === bertingkah laku sama saat berurusan dengan Non-Primitive Types seperti Objek dan Array. Mereka tidak membandingkan "isi", melainkan membandingkan "referensi memori".

let a = [1, 2, 3];
let b = [1, 2, 3];

console.log(a == b);  // false
console.log(a === b); // false

Lho, kok false? Padahal isinya sama persis! Hal ini karena a dan b menunjuk ke tempat penyimpanan yang berbeda di memori komputer kamu. Kecuali jika kamu melakukan ini:

let c = a;
console.log(a === c); // true (karena keduanya menunjuk ke array yang sama)

6. Object.is(): Alternatif Ketiga yang Jarang Dibahas

Selain == dan ===, JavaScript menyediakan metode Object.is(). Secara umum, Object.is() mirip dengan ===, tapi ada dua kasus khusus di mana mereka berbeda:

console.log(NaN === NaN);        // false
console.log(Object.is(NaN, NaN)); // true

console.log(+0 === -0);          // true
console.log(Object.is(+0, -0));  // false

Kapan menggunakan Object.is()?

  • Saat kamu perlu memperlakukan NaN sebagai sama dengan NaN (misalnya saat membandingkan hasil perhitungan matematika).
  • Saat kamu perlu membedakan antara +0 dan -0 (relevan di perhitungan grafis atau matematika tingkat lanjut).

Untuk kebutuhan sehari-hari, === tetap cukup. Tapi mengetahui keberadaan Object.is() akan membuat pemahamanmu tentang perbandingan di JavaScript lebih lengkap.

7. Kapan == Bisa Berguna?

Walaupun para ahli menyarankan ===, ada satu kasus di mana == bisa membuat kodemu lebih ringkas. Yaitu saat kamu ingin mengecek apakah sebuah variabel itu null atau undefined sekaligus.

Tanpa ==:

if (input === null || input === undefined) {
    // lakukan sesuatu
}

Dengan ==:

if (input == null) {
    // baris ini akan jalan jika input bernilai null ATAU undefined
}

Cara ini sering digunakan oleh pengembang berpengalaman untuk mempersingkat kode. Tapi kamu harus benar-benar paham risikonya dan pastikan rekan satu timmu juga mengerti pola ini. Jika tidak, gunakan versi eksplisit dengan === agar kode lebih mudah dibaca.

8. Tabel Perbandingan

Agar kamu lebih mudah memvisualisasikannya, perhatikan tabel perbandingan di bawah ini untuk beberapa nilai yang sering membingungkan:

Perbandingan Hasil (==) Hasil (===)
0 vs "0" true false
0 vs false true false
"" vs false true false
[] vs "" true false
null vs undefined true false
NaN vs NaN false false
+0 vs -0 true true

9. Kesimpulan

TL;DR: Gunakan === secara default. Gunakan == hanya untuk null/undefined check dengan sengaja. Kenali Object.is() untuk kasus khusus NaN dan +0/-0.

Jika kamu ingin menjadi pengembang JavaScript yang profesional, peganglah prinsip ini: Gunakan === (Strict Equality) secara default.

Jangan biarkan JavaScript membuat asumsi tentang tipe datamu. Dengan menggunakan ===, kamu memaksa dirimu sendiri untuk lebih sadar akan tipe data yang kamu kelola. Jika kamu mengharapkan sebuah angka dari API atau input form, pastikan kamu melakukan konversi tipe secara eksplisit (seperti menggunakan Number() atau parseInt()) sebelum membandingkannya.

Mengandalkan == secara sembarangan meningkatkan risiko bug yang sulit dilacak, terutama saat bekerja dengan tim. Mulai sekarang, tambahkan satu karakter lagi di operator perbandinganmu, dan rasakan ketenangan pikiran saat menulis kode!

Checklist Sebelum Publish Kode

  • ☐ Apakah semua perbandingan menggunakan ===?
  • ☐ Jika ada == null, apakah sudah dikomentari dengan jelas?
  • ☐ Apakah input dari API/form sudah dikonversi tipenya sebelum dibandingkan?
  • ☐ Apakah perbandingan objek/array memang sengaja memeriksa referensi, bukan isi?

Semoga artikel ini membantumu memahami perbedaan mendasar antara perbandingan == dan === di JS. Jangan lupa untuk terus bereksperimen di konsol browser kamu agar semakin paham dengan perilaku unik bahasa pemrograman ini!

Aurealisa ID
Fakta Gambar (Science Fact), Kutipan (Quote Of The Day), Ulasan (Science Review), Tips, Artikel.
Profil

Komentar