Operator Pembanding JavaScript

Pada tutorial ini, Anda akan mempelajari cara menggunakan operator perbandingan JavaScript untuk membandingkan dua nilai.

Pengenalan Operator Perbandingan JavaScript

Untuk membandingkan dua nilai, Anda menggunakan operator perbandingan. Tabel berikut menunjukkan operator perbandingan dalam JavaScript:

Operator	Arti
<	kurang dari
>	lebih besar dari
<=	kurang dari atau sama dengan
>=	lebih dari atau sama dengan
==	sama dengan
!=	tidak sama dengan

Sebuah operator perbandingan mengembalikan nilai Boolean yang menunjukkan apakah perbandingannya benar atau tidak. Lihat contoh berikut:

let r1 = 20 > 10; // true
let r2 = 20 < 10; // false
let r3 = 10 == 10; // true

Operator Perbandingan JavaScript

Sebuah operator perbandingan membutuhkan dua nilai. Jika tipe nilai tidak dapat dibandingkan, operator perbandingan mengonversi mereka menjadi tipe yang dapat dibandingkan sesuai dengan aturan tertentu.

Membandingkan Angka

Jika nilai berupa angka, operator perbandingan melakukan perbandingan numerik. Contoh:

let a = 10, 
    b = 20; 

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

Membandingkan String

Jika operand berupa string, JavaScript membandingkan kode karakter secara numerik satu per satu.

let name1 = 'alice',
    name2 = 'bob';    

let result = name1 < name2;
console.log(result); // true
console.log(name1 == 'alice'); // true

Namun, perhatikan bahwa perbandingan karakter dapat memberikan hasil yang tidak terduga. Untuk mengatasinya, ubah string ke format umum, misalnya huruf kecil atau besar.

let f1 = 'apple',
    f2 = 'Banana';

let result = f2.toLowerCase() < f1.toLowerCase();
console.log(result); // false

Membandingkan Angka dengan Nilai dari Tipe Lain

Jika satu nilai adalah angka dan yang lainnya bukan, operator perbandingan akan mengonversi nilai non-numerik menjadi angka untuk perbandingan numerik.

console.log(10 < '20'); // true
console.log(10 == '10'); // true

Membandingkan Objek dengan Non-Objek

Jika nilai adalah objek, metode valueOf() dari objek tersebut dipanggil untuk mengembalikan nilai perbandingan. Jika objek tidak memiliki metode valueOf(), metode toString() dipanggil sebagai gantinya.

let apple = {
  valueOf: function () {
    return 10;
  },
};

let orange = {
  toString: function () {
    return '20';
  },
};
console.log(apple > 10); // false
console.log(orange == 20); // true

Membandingkan Boolean dengan Nilai Lain

Jika nilai adalah Boolean, JavaScript mengonversinya menjadi angka untuk perbandingan; true dikonversi menjadi 1 dan false menjadi 0.

console.log(true > 0); // true
console.log(false < 1); // true
console.log(true > false); // true
console.log(false > true); // false
console.log(true >= true); // true
console.log(true <= true); // true
console.log(false <= false); // true
console.log(false >= false); // true

Selain aturan di atas, operator sama dengan (==) dan tidak sama dengan (!=) memiliki aturan berikut.

Membandingkan null dan undefined

Dalam JavaScript, null sama dengan undefined. Artinya, ekspresi berikut mengembalikan true.

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

Membandingkan NaN dengan Nilai Lain

Jika salah satu nilai adalah NaN, operator sama dengan (==) mengembalikan false.

console.log(NaN == 1); // false
console.log(NaN == NaN); // false

Operator tidak sama dengan (!=) mengembalikan true saat membandingkan NaN dengan nilai lain.

console.log(NaN != 1); // true
console.log(NaN != NaN); // true

Strict Equal (===) dan Not Strict Equal (!==)

Selain operator perbandingan di atas, JavaScript menyediakan operator strict equal (===) dan not strict equal (!==).

Operator	Makna
===	sama persis
!==	tidak sama persis

Operator strict equal dan not strict equal berperilaku seperti operator sama dengan dan tidak sama dengan, kecuali bahwa mereka tidak mengonversi operan sebelum perbandingan. Lihat contoh berikut:

console.log("10" == 10); // true
console.log("10" === 10); // false

Pada perbandingan pertama, karena kami menggunakan operator kesetaraan, JavaScript mengonversi string menjadi angka dan melakukan perbandingan. Namun, pada perbandingan kedua, kami menggunakan operator strict equal (===); JavaScript tidak mengonversi string sebelum perbandingan, sehingga hasilnya adalah false.

Dengan tutorial ini, Anda telah mempelajari cara menggunakan operator perbandingan JavaScript untuk membandingkan nilai.