Ads by Yasya El Hakim
Mengenal Perbandingan pada JavaScript

Kebanyakan, istilah yang ada di JavaScript atau bahasa pemrograman lainnya sering kita dengar di sekolah khususnya pada pelajaran matematika. Berikut adalah beberapa operasi matematika beserta penjelasannya yang dapat diterapkan pada JavaScript:
  • Lebih/Kurang dari: a > b, a < b.
  • Lebih/Kurang dari atau sama dengan: a >= b, a <= b.
  • Sama dengan: a == b (Perlu diingat bahwasannya menggunakan dua tanda sama dengan "==". Satu tanda sama dengan "=" artinya adalah penetapan/assignment).
  • Tidak sama dengan. Beda dengan simbol pada matematika, pada JavaScript, simbol tidak sama dengan ditulis seperti a != b.



Boolean Adalah Hasilnya

Sama seperti operator lainnya, sebuah perbandingan akan menghasilkan suatu nilai. Dalam hal ini, nilainya adalah boolean:
  • true - artinya ya atau benar.
  • false - artinya tidak atau salah.

Perhatikanlah contoh berikut:

alert( 2 > 1 );  // true (benar)
alert( 2 == 1 ); // false (salah)
alert( 2 != 1 ); // true (benar)


Hasil dari perbandingan juga dapat ditetapkan pada variabel, sama seperti nilai lainnya. Contoh:

let hasil = 5 > 4; // Menetapkan hasil dari perbandingan
alert(hasil); // true


Perbandingan String pada JavaScript

Untuk melihat apakah string lebih besar dari yang lain, JavaScript menggunakan suatu urutan istilah yang dinamakan "Dictionary" atau "Lexicographical".

Dengan kata lain, string akan dibandingkan huruf per huruf. Contoh:

alert('Z' > 'A'); // true
alert('Teras' > 'Terang'); // true
alert('Banner' > 'Ban'); // true


Algoritma dalam perbadingan dua string sangatlah mudah:
  • Bandingkan karakter pertama dari kedua string.
  • Jika karakter pertama dari string pertama lebih besar atau lebih kecil dari string lain, maka string pertama adalah yang lebih besar atau lebih kecil dari string kedua.
  • Selain itu, jika karakter pertama dari kedua string sama, maka akan membandingkan karakter kedua dengan cara yang sama juga.
  • Akan terus diulangi sampai karakter pada string habis.
  • Jika panjang dari kedua string itu sama, maka artinya sama dan tidak ada yang lebih besar.

Pada contoh diatas, perbandingan 'Z' > 'A' akan menghasilkan seperti langkah algoritma pertama. Sedangkan string 'Teras' dan 'Terang' akan di bandingkan karakter demi karakter.
  • T sama seperti T
  • e sama seperti e
  • r sama seperti r
  • a sama seperti a
  • s lebih besar dari n. Maka akan berhenti disini. String pertama adalah yang terbesar.

Dictionary atau Unicode?

Perbandingan algoritma yang sudah saya tunjukkan diatas itu sama seperti menggunakan aplikasi kontak pada smartphone, tetapi tidak sama sepenuhnya.

Contoh, besar kecilnya huruf sangat berpengaruh. Huruf kapital "A" tidak sama dengan huruf kecil "a", manakah yang lebih besar? Jawabannya adalah "a". Mengapa? Karena huruf kecil memiliki index yang lebih besar pada tabel encoding yang digunakan pada JavaScript (Unicode). Kita akan membahasnya secara rinci pada bagian selanjutnya.

Perbandingan Tipe yang Berbeda pada JavaScript

Ketika kita membandingkan nilai dari tipe yang berbeda, JavaScript akan mengubah nilainya menjadi angka. Contoh:

alert('2' > 1); // true, string '2' akan menjadi angka 2
alert('01' == 1); // true, string '01' akan menjadi angka 1


Untuk nilai Boolean, true akan menjadi 1 dan false akan menjadi 0. Contoh:

alert(true == 1); // true
alert(false == 0); // true


Urutan yang Menyenangkan

Sangatlah mungkin bagi kita untuk melakukan perbandingan pada waktu yang sama:
  • Dua nilai yang sama
  • Satu diantaranya adalah true dan yang lainnya adalah false sebagai boolean.

Perhatikan contoh berikut:

let a = 0;
alert(Boolean(a)); // false

let b = "0";
alert(Boolean(b)); // true

alert(a == b); // true


Batasan Perbandingan pada JavaScript

Terdapat masalah dalam proses pengecekan persamaan "==". Persamaan tersebut tidak dapat membedakan 0 dari false:

alert(0 == false); // true


Hal yang terjadi juga sama dengan string kosong:

alert('' == false); // true


Hal tersebut dapat terjadi karena operand dari tipe yang berbeda telah diubah kedalam angka dengan menggunakan operator persamaan "==". String yang kosong akan sama seperti false, yaitu menjadi 0.

Apa yang harus kita lakukan jika kita ingin membedakan 0 dari false?

Operator batasan Perbandingan dalam persamaan (Strict Equality) dapat mengecek persamaan tanpa tipe konversi.

Dengan kata lain, jika a dan b adalah tipe yang berbeda, maka a === b akan langsung menghasilkan false tanpa mengubahnya. Mari kita coba:

alert(0 === false); // false, karena tipe nya berbeda


Terdapat juga operator batasan yang tidak sama (Strict non-Equality) yang dapat ditulis seperti !==.

Perbandingan null dan undefined pada JavaScript

Terdapat tindakan non-intuitif ketika null atau undefined di bandingkan dengan nilai lain.

Pengecekan Strict Equality ===

Nilainya berbeda karena setiap nilai adalah tipe yang berbeda. Contoh:

alert(null === undefined); // false


Pengecekan Non-Strict Equality ==

Terdapat aturan spesial. Keduanya adalah berpasangan dan sama satu sama lain, tetapi tidak dengan nilai yang lain. Contoh:

alert(null == undefined); // true


Matematika dan Perbandingan lainnya <, >, <=, >=

null/undefined akan dibuah menjadi angka: null akan menjadi 0, sedangkan undefined menjadi NaN.

Sekarang mari kita lihat beberapa hal yang akan terjadi ketika kita menggunakan aturan tersebut dan apa hal pentingnya serta bagaimana agar kita tidak terjebak oleh nya.

Hasil asing: null vs 0

Mari kita bandingkan null dengan angka 0:

alert(null > 0);  // (1) false
alert(null == 0); // (2) false
alert(null >= 0); // (3) true


Secara matematika, hal tersebut sangatlah asing. Hasil akhir menunjukkan bahwa null lebih besar atau sama dengan 0. Jadi, pada satu perbandingan diatas harus menjadi true, tetapi terdapat dua yang false.

Alasannya adalah persamaan == dan perbandingan <, >, <=, >= bekerja dengan cara yang berbeda. Perbandingan mengubah null menjadi angka, itulah mengapa nomor (3) alert(null >= 0); hasilnya adalah true dan nomor (1) alert(null > 0); hasilnya adalah false.

Dengan kata lain, persamaan == untuk undefined dan null ditentukan seperti itu tanpa konversi apapun, mereka akan sama dan tidak sama dengan apapun. Itulah mengapa nomor (2) alert(null == 0); adalah false.

Tidak Dapat Membandingkan undefined

Nilai dari undefined harusnya tidak dapat dibandingkan dengan nilai lain:

alert(undefined > 0); // false (1)
alert(undefined < 0); // false (2)
alert(undefined == 0); // false (3)


Mengapa angka 0 tidak disukai dan hasilnya selalu false?

Kita mendapatkan hasil tersebut karena:
  • Perbandingan nomor (1) dan (2) akan menghasilkan false karena undefined telah diubah menjadi NaN dan NaN adalah nilai angka yang spesial dan akan menghasilkan false untuk semua perbandingan.
  • Persamaan nomor (3) akan menghasilkan false karena undefined hanya sama dengan null, undefined, dan tidak ada nilai lainya.

0Komentar

Sebelumnya Selanjutnya