JavaScript Dasar: Operator Perbandingan

Operator perbandingan atau comparison operators membandingkan dua buah operand. Apabila pernyataan perbandingan tersebut benar akan menghasilkan nilai `true`, sebaliknya `false`. 

Daftar Operator Perbandingan

Berikut daftar operator perbandingan dalam JavaScript

Operator	Deskripsi	Contoh Penggunaan
==	Sama dengan (Equal to)	5 == 5 => true
!=	Tidak sama dengan (Not equal to)	5 != 7 => true
===	Kesamaan nilai dan tipe data. (Strict Equal)	5 === '5' => false
!==	Ketidaksamaan nilai dan tipe data. (Strict Inequal)	5 !== '5' => true
>	Lebih besar dari (Greater than)	7 > 5 => true
<	Lebih kecil dari (Less than)	5 < 7 => true
>=	Lebih besar dari atau sama dengan (Greater than or equal to)	5 >= 5 => true
<=	Lebih kecil dari atau sama dengan (Less than or equal to)	5 <= 5 => true

Dalam JavaScript, pengecekan `sama dengan` menggunakan dua tanda sama dengan(`==`), karena tanda sama dengan `=` digunakan sebagai assignment operator. 

Kemudian simbol tidak sama dengan dalam matematika ( `≠` ) digantikan dengan `!=` di JavaScript.

Perbandingan Menghasilkan Boolean (true/false)

Setiap perbandingan akan menghasilkan data Boolean. 

• `True` - Berarti perbandingan benar
• `False` - Berarti perbandingan tidak benar

Contoh: 

console.log(2 > 4); // false

console.log(2 == 4 - 2) // true

Hasil perbandingan dapat disimpan di variabel. 

const result = 10 >= 8; // menyimpan hasil perbandingan ke variabel

console.log(result); // true

Kesamaan Nilai (Equality)

Operator `==` hanya membandingkan dua buah nilai tanpa memastikan apakah tipe datanya sama. Membandingkan number dengan string, Boolean dengan number dapat bernilai true karena JavaScript akan mengonversi menjadi tipe data yang sama. 

Membandingkan `number` dengan `string`: 

1 == '1'; // true

1 == 'satu'; // false

Dari dua contoh di atas, JavaScript mengubah string ke number. Pada contoh yang kedua, konversi `'satu'` ke number menghasilkan `NaN`. Sehingga hasil perbandingannya menjadi `false`. 

`NaN` dengan `NaN` tidak akan pernah sama: 

NaN == NaN; // false

Membandingkan `number` dengan `bigint` akan bernilai true jika memiliki nilai numerik yang sama: 

const number = 165478;

const bigint = 165478n;

number == bigint; // true

Begitu juga membandingkan `string` dengan `bigint`, string akan diubah ke bigint: 

const string = '165478';

const bigint = 165478n;

string == bigint; // true

Membandingkan `number` dengan `Boolean`: 

1 == true; // true

0 == false; // true

Boolean `true` diwakili oleh angka `1`, sedangkan `false` diwakili `0`. 

Pada perbandingan number dengan Boolean, JavaScript mengubah Boolean menjadi number. Karena inilah kedua perbandingan number-boolean di atas menghasilkan true

Membandingkan dua buah objek bernilai `true` jika merujuk pada objek yang sama:

const objek = {};

const objek2 = {};

objek == objek; // true

objek == objek2; // false

Meskipun kedua objek di atas sama-sama kosong, membandingkan dua objek yang berbeda tetap menghasilkan `false`. 

Membandingkan dua `Symbol` yang berbeda akan bernilai `false` karena setiap `Symbol` bernilai unik. 

const symb1 = Symbol('Deskripsi');

const symb2 = Symbol('Deskripsi');

symb1 == symb1; // true

symb1 == symb2; // false

Membandingkan `null` dengan `undefined`: 

null == undefined; // true

Kesamaan Nilai dan Tipe (Strict Equality) 

Operator `===` membandingkan kedua tipe operand, jika tipenya sama akan dilanjut membandingkan nilainya. Namun jika tipenya berbeda, akan langsung menghasilkan `false`. 

Dengan operator ini, JavaScript tidak akan mengkonversi tipe data. 

String tidak lagi dikonversi ke number

1 === 1; // true

1 === '1'; // false

Boolean tidak lagi dikonversi ke number.

1 === true; // false

0 === false; // false

`number` ke `bigint` tidak lagi sama, meskipun nilainya sama: 

const number = 165478;

const bigint = 165478n;

number === bigint; // false

`null` dan `undefined` adalah tipe data yang berbeda. 

null === undefined; // false

Ketidaksamaan Nilai (Inequality)

Operator `!=` akan menghasilkan `true` bila kedua operand berbeda nilai. Opetor ini adalah kebalikan atau negasi atau ingkaran dari equality (==). 

1 == '1'; // true

1 != '1'; // false

Karena kedua operand bernilai sama, maka menghasilkan `false`. 

Operator ini akan bernilai sama dengan: 

!(1 == '1'); // false

Tanda Seru `!` adalah sebuah operator logika (NOT) yang membalikkan keadaan. Bilamana keadaan bernilai `true`, maka menjadi `false`. Dan sebaliknya. 

Kamu akan mempelajari operator logika atau Logical Operator di artikel lain. 

Operator `!=` akan menghasilkan `true` bila kedua operand berbeda nilai. Opetor ini adalah kebalikan atau negasi atau ingkaran dari equality (==). 

1 == '1'; // true

1 != '1'; // false

Karena kedua operand bernilai sama, maka menghasilkan `false`. 

Operator ini akan bernilai sama dengan: 

!(1 == '1'); // false

Tanda Seru `!` adalah sebuah operator logika (NOT) yang membalikkan keadaan. Bilamana keadaan bernilai `true`, maka menjadi `false`. Dan sebaliknya. 

Kamu akan mempelajari operator logika atau Logical Operator di artikel lain. 

Ketidaksamaan Nilai dan Tipe data (Strict Inequality)

Operator `!==` akan menghasilkan `true` bila kedua operand berbeda tipe. Opetor ini adalah kebalikan atau negasi atau ingkaran dari strict equality (===). 

Pertama, operator ini akan mengecek kesamaan tipe data, lalu membalikkan nilainya. Jika tipe datanya sama, yang seharusnya bernilai `true` operator ini membalikkan nilainya menjadi `false`. 

1 === 1; // true

1 !== 1; // false

Operator ini akan bernilai sama dengan: 

!(1 === 1); // false

Membandingkan String

Operator sama dengan `==` dapat digunakan untuk mengecek kesamaan dari dua buah string. 

const str1 = "Helo";

const str2 = "Helo";

str1 == str2; // true

Bisa juga menggunakan operator greater than `>` atau less than `<` untuk membandingkan dua buah string. 

const str1 = "A";

const str2 = "B";

str1 > str2; // false

Kedua string di atas dibandingkan berdasarkan urutan abjad. JavaScript membandingkan karakter demi karakter. 

Di contoh di atas, karena posisi `A` di abjad lebih kecil daripada posisi `B`, maka perbandingan `str1 > str2` bernilai `false`, karena posisi `B` lebih besar. 

Meskipun operator perbandingan dapat melakukan perbandingan dua buah string, direkomendasikan untuk menggunakan metode `localCompare()`. Kamu akan mempelajarinya di artikel lain. 

Penggunaan Operator Perbandingan

Kapan ini digunakan? 

Operator perbandingan ini digunakan dalam pernyataan kondisional (conditional statement) seperti pada percabangan `if...else`. Hasil dari perbandingan (true/false) akan menentukan jalannya program. 

let x = 5;

let y = 3;

if (x == y) {

    console.log("Nilai x sama dengan y");

} else {

    console.log("Nilai x tidak sama dengan y");

}

Pada contoh di atas, jika nilai `x` sama dengan nilai `y`, maka pesan "Nilai x sama dengan y" akan dicetak. Jika tidak, maka pesan "Nilai x tidak sama dengan y" akan dicetak.

Juga dalam perulangan untuk membatasi perulangan. 

let i = 1;

while (i <= 5) {

    console.log(i);

    i++;

}

Pada contoh di atas, kita memeriksa apakah nilai `i` kurang dari atau sama dengan 5. Jika kondisi tersebut terpenuhi, maka nilai `i` akan dicetak dan kemudian nilai `i` akan ditambah 1 dengan increment (++). 

Proses ini akan terus berulang hingga nilai `i` mencapai 6, di mana kondisi `i <= 5` tidak lagi terpenuhi, dan perulangan berhenti.