JavaScript - Operator Perbandingan

Halo sana, para ahli JavaScript masa depan! Hari ini, kita akan mendalam ke dunia magis operator perbandingan. Jangan khawatir jika Anda belum pernah menulis baris kode sebelumnya - saya akan menjadi panduan yang ramah dalam perjalanan yang menarik ini. Jadi, ambil keyboard Anda (aku maksud keyboard, bukan tongkat sihir), dan mari kita mulai!

Operator Perbandingan JavaScript

Operator perbandingan mirip dengan juri di dunia pemrograman. Mereka melihat dua nilai dan menentukan hubungan mereka. Apakah mereka sama? Apakah salah satu 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 perbandingan yang kita akan bahas hari ini:

Operator	Nama	Contoh
==	Kesetaraan	x == y
!=	Tidak Sama	x != y
===	Kesetaraan Kekeras	x === y
!==	Tidak Sama Kekeras	x !== y
>	Lebih Besar	x > y
>=	Lebih Besar atau Sama	x >= y
<	Lebih Kecil	x < y
<=	Lebih Kecil atau Sama	x <= y

Bagaimana perbandingan dilakukan?

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

1. Jika kita membandingkan angka, itu mudah. JavaScript memeriksa angka mana 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 mengkonversi jenis salah satu sebelum membandingkan.

Sekarang, mari kita lihat setiap operator secara detil.

Operator Kesetaraan (==) JavaScript

Operator kesetaraan (==) memeriksa jika dua nilai sama, tetapi itu agak fleksibel. Itu dapat mengkonversi 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 mengkonversi 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 Tidak Sama (!=) JavaScript

Operator tidak sama (!=) adalah seperti kebalikan 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 adalah seperti saudara tua ketat dari ==. Itu tidak hanya memeriksa nilai tapi 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 Tidak Sama Kekeras (!==) Operator

Operator tidak sama kekeras (!==) adalah kebalikan 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 (>) JavaScript

Operator lebih besar (>) 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, bukan urutan alfabetik!

Operator Lebih Besar atau Sama (>=) Operator

Operator lebih besar atau sama (>=) 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 (<) JavaScript

Operator lebih kecil (<) 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 atau Sama (<=) JavaScript

Operator lebih kecil atau sama (<=) 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 perbandingan dikonversi ke 0, tapi tidak dalam pemeriksaan kesetaraan.

Dan itu adalah semuanya, teman-teman! Kita telah berpergian melalui negeri operator perbandingan JavaScript. Ingat, latihan membuat sempurna, jadi jangan takut untuk mencoba operator ini dalam kode Anda sendiri. Selamat coding!

Credits: Image by storyset