Kita mengetahui banyak operator perbandingan dari matematika.
Dalam JavaScript ditulis seperti ini:
Lebih besar/kurang dari: a > b , a < b .
Lebih besar/kurang dari atau sama dengan: a >= b , a <= b .
Sama dengan: a == b , harap diperhatikan tanda persamaan ganda == berarti ujian kesetaraan, sedangkan tanda tunggal a = b berarti tugas.
Tidak sama: Dalam matematika notasinya adalah ≠ , tetapi dalam JavaScript ditulis sebagai a != b .
Dalam artikel ini kita akan mempelajari lebih lanjut tentang berbagai jenis perbandingan, cara JavaScript membuatnya, termasuk kekhasan penting.
Pada akhirnya Anda akan menemukan resep yang bagus untuk menghindari masalah terkait “kekhasan JavaScript”.
Semua operator perbandingan mengembalikan nilai boolean:
true – berarti “ya”, “benar” atau “kebenaran”.
false – berarti “tidak”, “salah” atau “tidak benar”.
Misalnya:
peringatan( 2 > 1 ); // benar (benar) peringatan( 2 == 1 ); // salah (salah) peringatan( 2 != 1 ); // benar (benar)
Hasil perbandingan dapat diberikan ke variabel, sama seperti nilai apa pun:
misalkan hasil = 5 > 4; // menetapkan hasil perbandingan peringatan(hasil); // BENAR
Untuk melihat apakah suatu string lebih besar dari yang lain, JavaScript menggunakan apa yang disebut urutan “kamus” atau “leksikografis”.
Dengan kata lain, string dibandingkan huruf demi huruf.
Misalnya:
peringatan('Z' > 'A'); // BENAR
alert( 'Bersinar' > 'Glee' ); // BENAR
alert('Lebah' > 'Jadilah'); // BENARAlgoritme untuk membandingkan dua string sederhana saja:
Bandingkan karakter pertama dari kedua string.
Jika karakter pertama dari string pertama lebih besar (atau lebih kecil) dari string lainnya, maka string pertama lebih besar (atau lebih kecil) dari string kedua. Kita sudah selesai.
Sebaliknya, jika karakter pertama kedua string sama, bandingkan karakter kedua dengan cara yang sama.
Ulangi sampai akhir senar mana pun.
Jika kedua tali mempunyai panjang yang sama maka kedua tali tersebut sama panjang. Jika tidak, semakin panjang stringnya, semakin besar.
Pada contoh pertama di atas, perbandingan 'Z' > 'A' membuahkan hasil pada langkah pertama.
Perbandingan kedua 'Glow' dan 'Glee' memerlukan lebih banyak langkah karena string dibandingkan karakter demi karakter:
G sama dengan G
l sama dengan l .
o lebih besar dari e . Berhenti di sini. Senar pertama lebih besar.
Bukan kamus sungguhan, tapi tatanan Unicode
Algoritme perbandingan yang diberikan di atas kira-kira setara dengan yang digunakan dalam kamus atau buku telepon, namun tidak persis sama.
Misalnya, masalah kasus. Huruf kapital "A" tidak sama dengan huruf kecil "a" . Mana yang lebih hebat? Huruf kecil "a" . Mengapa? Karena karakter huruf kecil memiliki indeks lebih besar pada tabel pengkodean internal yang digunakan JavaScript (Unicode). Kita akan kembali ke detail spesifik dan konsekuensinya di bab Strings.
Saat membandingkan nilai dari tipe yang berbeda, JavaScript mengonversi nilai menjadi angka.
Misalnya:
peringatan('2' > 1 ); // benar, string '2' menjadi angka 2
peringatan('01' == 1 ); // benar, string '01' menjadi angka 1 Untuk nilai boolean, true menjadi 1 dan false menjadi 0 .
Misalnya:
waspada( benar == 1 ); // BENAR waspada( salah == 0 ); // BENAR
Sebuah konsekuensi yang lucu
Mungkin saja pada saat yang sama:
Dua nilai sama.
Salah satunya true sebagai boolean dan yang lainnya false sebagai boolean.
Misalnya:
misalkan a = 0; peringatan( Boolean(a) ); // PALSU misalkan b = "0"; peringatan( Boolean(b) ); // BENAR peringatan(a == b); // BENAR!
Dari sudut pandang JavaScript, hasil ini cukup normal. Pemeriksaan kesetaraan mengonversi nilai menggunakan konversi numerik (karenanya "0" menjadi 0 ), sedangkan konversi Boolean eksplisit menggunakan seperangkat aturan lain.
Pemeriksaan kesetaraan reguler == bermasalah. Itu tidak dapat membedakan 0 dari false :
peringatan( 0 == salah ); // BENAR
Hal yang sama terjadi dengan string kosong:
peringatan('' == salah ); // BENAR Hal ini terjadi karena operan dengan tipe berbeda diubah menjadi angka oleh operator persamaan == . String kosong, sama seperti false , menjadi nol.
Apa yang harus dilakukan jika kita ingin membedakan 0 dari false ?
Operator kesetaraan yang ketat === memeriksa kesetaraan tanpa konversi tipe.
Dengan kata lain, jika a dan b bertipe berbeda, maka a === b segera mengembalikan false tanpa berusaha mengonversinya.
Mari kita mencobanya:
peringatan( 0 === salah ); // salah, karena tipenya berbeda
Ada juga operator “non-kesetaraan ketat” !== analog dengan != .
Operator kesetaraan yang ketat membutuhkan waktu yang lebih lama untuk ditulis, namun memperjelas apa yang terjadi dan memberikan lebih sedikit ruang untuk kesalahan.
Ada perilaku non-intuitif ketika null atau undefined dibandingkan dengan nilai lain.
Untuk pemeriksaan kesetaraan yang ketat ===
Nilai-nilai ini berbeda-beda, karena masing-masing mempunyai tipe yang berbeda.
peringatan( null === tidak terdefinisi ); // PALSU
Untuk pemeriksaan tidak ketat ==
Ada aturan khusus. Keduanya adalah “pasangan manis”: mereka setara satu sama lain (dalam arti == ), tetapi tidak dengan nilai lainnya.
peringatan( null == tidak terdefinisi ); // BENAR
Untuk matematika dan perbandingan lainnya < > <= >=
null/undefined diubah menjadi angka: null menjadi 0 , sedangkan undefined menjadi NaN .
Sekarang mari kita lihat beberapa hal lucu yang terjadi saat kita menerapkan aturan ini. Dan yang lebih penting, bagaimana agar tidak terjebak dengan mereka.
Mari kita bandingkan null dengan nol:
peringatan( null > 0 ); // (1) salah waspada( null == 0 ); // (2) salah peringatan( null >= 0 ); // (3) benar
Secara matematis, itu aneh. Hasil terakhir menyatakan “ null lebih besar atau sama dengan nol”, jadi pada salah satu perbandingan di atas pasti true , namun keduanya salah.
Alasannya adalah pemeriksaan kesetaraan == dan perbandingan > < >= <= bekerja secara berbeda. Perbandingan mengubah null menjadi angka, memperlakukannya sebagai 0 . Itu sebabnya (3) null >= 0 benar dan (1) null > 0 salah.
Di sisi lain, pemeriksaan kesetaraan == untuk undefined dan null didefinisikan sedemikian rupa sehingga, tanpa konversi apa pun, keduanya setara satu sama lain dan tidak sama dengan apa pun. Itu sebabnya (2) null == 0 salah.
Nilai undefined tidak boleh dibandingkan dengan nilai lainnya:
peringatan( tidak terdefinisi > 0 ); // salah (1) peringatan( tidak terdefinisi < 0 ); // salah (2) waspada( tidak terdefinisi == 0 ); // salah (3)
Mengapa ia sangat tidak menyukai angka nol? Selalu salah!
Kami mendapatkan hasil ini karena:
Perbandingan (1) dan (2) menghasilkan false karena undefined dikonversi menjadi NaN dan NaN adalah nilai numerik khusus yang mengembalikan nilai false untuk semua perbandingan.
Pemeriksaan kesetaraan (3) menghasilkan false karena undefined hanya sama dengan null , undefined , dan tidak ada nilai lainnya.
Mengapa kami membahas contoh-contoh ini? Haruskah kita mengingat keanehan ini sepanjang waktu? Ya, tidak juga. Sebenarnya, hal-hal rumit ini lambat laun akan menjadi akrab seiring berjalannya waktu, namun ada cara jitu untuk menghindari masalah dengan hal tersebut:
Perlakukan perbandingan apa pun dengan undefined/null kecuali persamaan ketat === dengan sangat hati-hati.
Jangan gunakan perbandingan >= > < <= dengan variabel yang mungkin null/undefined , kecuali Anda benar-benar yakin dengan apa yang Anda lakukan. Jika suatu variabel dapat memiliki nilai-nilai ini, periksa secara terpisah.
Operator perbandingan mengembalikan nilai boolean.
String dibandingkan huruf demi huruf dalam urutan “kamus”.
Ketika nilai dari tipe yang berbeda dibandingkan, nilai tersebut akan dikonversi menjadi angka (dengan pengecualian pemeriksaan kesetaraan yang ketat).
Nilai null dan undefined sama dengan == satu sama lain dan tidak sama dengan nilai lainnya.
Berhati-hatilah saat menggunakan perbandingan seperti > atau < dengan variabel yang terkadang bernilai null/undefined . Memeriksa null/undefined secara terpisah adalah ide yang bagus.
pentingnya: 5
Apa akibat dari ungkapan-ungkapan ini?
5 > 4 "apel" > "nanas" "2" > "12" tidak terdefinisi == nol tidak terdefinisi === nol nol == "n0n" batal === +"n0n"
5 > 4 → benar "apel" > "nanas" → salah "2" > "12" → benar tidak terdefinisi == nol → benar tidak terdefinisi === nol → salah null == "n0n" → salah null === +"n0n" → salah
Beberapa alasannya:
Jelas sekali benar.
Perbandingan kamus, maka salah. "a" lebih kecil dari "p" .
Sekali lagi, perbandingan kamus, char pertama "2" lebih besar dari char pertama "1" .
Nilai null dan undefined sama satu sama lain saja.
Kesetaraan yang ketat itu ketat. Tipe yang berbeda dari kedua belah pihak mengarah pada kesalahan.
Mirip dengan (4) , null hanya sama dengan undefined .
Kesetaraan yang ketat dari berbagai jenis.