JavaScript - Pembandingan Operator

Hai teman-teman, para ahli JavaScript masa depan! Hari ini, kita akan mandar ke dunia magis operator pembandingan. Jangan khawatir jika Anda belum pernah menulis baris kode sebelumnya - saya akan menjadi panduan ramah Anda dalam perjalanan yang menarik ini. Jadi, ambil keyboard Anda (aku maksudkan wands, bukan keyboard), dan mari kita mulai!

Operator Pembandingan JavaScript

Operator pembandingan seperti para juri di dunia pemrograman. Mereka melihat dua nilai dan menentukan hubungan mereka. Apakah mereka sama? Apakah salah satunya lebih besar dari yang lain? Operator ini membantu kita membuat keputusan dalam kode kita, sama seperti kita membuat keputusan dalam kehidupan nyata.

Mari kita lihat semua operator pembandingan yang kita akan bahas hari ini:

Operator	Nama	Contoh
==	Kesetaraan	x == y
!=	Tak Kesetaraan	x != y
===	Kesetaraan Kekeras	x === y
!==	Tak Kesetaraan Kekeras	x !== y
>	Lebih Besar Dari	x > y
>=	Lebih Besar Dari Atau Sama Dengan	x >= y
<	Lebih Kecil Dari	x < y
<=	Lebih Kecil Dari Atau Sama Dengan	x <= y

Bagaimana pembandingan dilakukan?

Sebelum kita masuk ke setiap operator, mari kita pahami bagaimana JavaScript membandingkan nilai. Itu tidak terlalu berbeda dari bagaimana kita membandingkan hal-hal dalam kehidupan nyata!

1. Jika kita membandingkan angka, itu mudah. JavaScript memeriksa mana angka yang lebih besar.
2. Untuk string, JavaScript membandingkan mereka karakter per karakter, berdasarkan nilai Unicode mereka.
3. Jika kita membandingkan jenis yang berbeda (seperti angka dan string), JavaScript biasanya mencoba mengonversi jenis salah satu ke jenis lain sebelum membandingkan.

Sekarang, mari kita lihat setiap operator secara detil.

Operator Kesetaraan (==) JavaScript

Operator kesetaraan (==) memeriksa jika dua nilai sama, tapi itu agak fleksibel. Itu bisa mengonversi jenis sebelum membandingkan. Mari kita lihat beberapa contoh:

console.log(5 == 5);     // true
console.log(5 == "5");   // true
console.log(true == 1);  // true
console.log(null == undefined);  // true

Dalam contoh pertama, itu jelas mengapa kita mendapat true. Dalam yang kedua, JavaScript mengonversi string "5" ke angka sebelum membandingkan. Contoh ketiga mungkin mengejutkan Anda - JavaScript menganggap true sebagai 1 dan false sebagai 0. Contoh terakhir menunjukkan bahwa null dan undefined dianggap sama dengan operator ==.

Operator Tak Kesetaraan (!=) JavaScript

Operator tak kesetaraan (!=) seperti lawan dari ==. Itu memeriksa jika dua nilai tidak sama.

console.log(5 != 6);     // true
console.log(5 != "5");   // false
console.log(true != 1);  // false

Seperti ==, itu juga melakukan konversi jenis sebelum membandingkan.

Operator Kesetaraan Kekeras (===) JavaScript

Sekarang, mari kita temui operator kesetaraan kekeras (===). Operator ini seperti saudara tua ketat dari ==. Itu tidak hanya memeriksa nilai, tetapi juga memastikan jenisnya sama.

console.log(5 === 5);     // true
console.log(5 === "5");   // false
console.log(true === 1);  // false
console.log(null === undefined);  // false

Lihat bagaimana hasilnya berbeda dari ==? Operator kesetaraan kekeras tidak melakukan konversi jenis.

Operator Tak Kesetaraan Kekeras (!==) Operator

Operator tak kesetaraan kekeras (!==) adalah lawan dari ===. Itu memeriksa jika dua nilai tidak sama dalam nilai atau jenis.

console.log(5 !== 6);     // true
console.log(5 !== "5");   // true
console.log(true !== 1);  // true

Operator Lebih Besar Dari (>) JavaScript

Operator lebih besar dari (>) memeriksa jika nilai kiri lebih besar dari nilai kanan.

console.log(10 > 5);   // true
console.log(5 > 10);   // false
console.log(10 > 10);  // false
console.log("b" > "a");  // true (membandingkan nilai Unicode)

Ingat, saat membandingkan string, itu berdasarkan nilai Unicode mereka, bukan urutan abjadnya!

Operator Lebih Besar Dari Atau Sama Dengan (>=) Operator

Operator lebih besar dari atau sama dengan (>=) memeriksa jika nilai kiri lebih besar atau sama dengan nilai kanan.

console.log(10 >= 5);   // true
console.log(10 >= 10);  // true
console.log(5 >= 10);   // false

Operator Lebih Kecil Dari (<) JavaScript

Operator lebih kecil dari (<) memeriksa jika nilai kiri lebih kecil dari nilai kanan.

console.log(5 < 10);   // true
console.log(10 < 5);   // false
console.log(10 < 10);  // false

Operator Lebih Kecil Dari Atau Sama Dengan (<=) JavaScript

Operator lebih kecil dari atau sama dengan (<=) memeriksa jika nilai kiri lebih kecil atau sama dengan nilai kanan.

console.log(5 <= 10);   // true
console.log(10 <= 10);  // true
console.log(10 <= 5);   // false

Membandingkan null, undefined, dan NaN

Membandingkan nilai khusus seperti null, undefined, dan NaN bisa sulit. Mari kita lihat beberapa contoh:

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

Perilaku dengan null dan undefined bisa mengejutkan. NaN tidak sama dengan apa pun, bahkan dirinya sendiri! Dan null dalam pembandingan dianggap sebagai 0, tapi tidak dalam pembandingan kesetaraan.

Dan itu dia, teman-teman! Kita telah berkeliling di negeri operator pembandingan JavaScript. Ingat, latihan membuat sempurna, jadi jangan takut untuk mencoba operator ini dalam kode Anda sendiri. Selamat coding!

Credits: Image by storyset