JS101 | Operator perbandingan di Javascript

Cocoklah untuk yang bingung dengan penggunaan statement yang butuh kondisi seperti looping, dan branching.

Photo by NordWood Themes on Unsplash

Operator persamaan ( == / === )

Di js, untuk membandingkan nilai antara dua buah primitive atau variabel dapat dilakukan dengan menggunakan operator persamaan. Operator persmaan dalam javascript terbagi menjadi dua, yaitu persamaan berdasarkan nilai atau equality (==), dan persamaan berdasarkan nilai dan tipe nya atau strict equality (===).

Contoh penggunaan:

1 == 1; // true
1 === 1; // true
1 == '1'; // true
1 === '1'; // false

Perlu diperhatikan saat membandingkan nilai dengan operator persamaan, jika ekspektasi dari nilai yang akan dibandingkan adalah sama dan tipenya pun juga sama, gunakanlah selalu operator persamaan strict equality, karena selain membandingkan nilai, tipe nya pun akan dicheck, contoh pada 1 === '1' akan menghasilkan false, karena nilainya benar sama, namun tipenya berbeda, yaitu number dan string.

Operator pertidaksamaan ( != / !== )

Selain persamaan, terdapat juga operator untuk check pertidaksamaan antar nilai atau variabel, sama dengan operator persamaan, operator ini pun juga memiliki strict inequality operator dengan menggunakan (!==).

Contoh penggunaan:

1 != 1; // false
1 !== 1; // false
1 != '1'; // false
1 !== '1'; // true

Operator relasional ( > , <, >=, <= )

Operator ini digunakan untuk membandingkan dua nilai numerik.

Terdiri dari beberapa operator:

Operator | Deskripsi
---------|-----------
>        | lebih dari
<        | kurang dari
>=       | lebih dari atau sama dengan
<=       | kurang dari atau sama dengan

Contoh Penggunaan:

1 > 1; // false
1 >= 1; // true
1 < 1; // false
1 <= 1; // true

1 > 2; // false
1 >= 2; // false
1 < 2; // true
1 <= 2; // true

Dalam operator relational, hanya nilai saja yang dibandingkan, tak ada operator strict yang dapat membandingkan nilai dan tipe.

Special Case, Null & Undefined

Membandingkan null dan undefined dengan operator persamaan.

null === undefined; // false
null == undefined; // true

null !== undefined; // true
null != undefined; // false

Terdapat aturan khusus dimana kedua nilai yang bersifat falsy ini jika dibandingkan dengan persamaan non strict equality akan bernilai true, sementara dengan operator strict equality akan bersifat false, karena null dan undefined memiliki tipe yang berbeda.

Membandingkan null dengan nilai 0 menggunakan operator relational.

null > 0; // false
null >= 0; // true
null < 0; // false
null <= 0; // true

Ketika terdapat operator relational, null akan dikonversi kedalam nilai numerik, yaitu 0, berikut adalah code untuk membuktikannya:

null > -1; // true
null >= 0; // true
null <= 0; // true
null < 1; // true

Membandingkan undefined dengan nilai 0 menggunakan operator relational.

undefined > 0; // false
undefined >= 0; // false
undefined < 0; // false
undefined <= 0; // false

Berbeda dengan null, undefined akan dikonversikan kedalam NaN, nilai NaN akan selalu menghasilkan false jika di bandingkan dengan bilangan lain. sehingga akan selalu menghasilkan nilai false seperti kode diatas.

Weird Case 0.1 + 0.2 === 0.3 returns false!

Kasus ini banyak terjadi, cukup aneh memang, penjelasan singkat mengapa kode 0.1 + 0.2 === 0.3 menghasilkan false karena 0.1 + 0.2 tidak akan menghasilkan bilangan 0.3 melainkan bilangan 0.30000000000000004. Ini terjadi karena javascript selalu menyimpan data numerik dengan tipe data double precision float. Penjelasan lengkap dapat di lihat di artikel medium ini.

Okay, sekarang sudah siap untuk bikin kondisi buat branching dan looping nih

Cheers 🥂

Originally published at https://hendrasadewa.site.