DON ' T Takut Kembar Evil - Sitepoint

pemaju JavaScript Douglas Crockford pernah merujuk kepada pengendali JavaScript

dan == sebagai "kembar jahat" yang harus dielakkan. Walau bagaimanapun, apabila anda memahaminya, pengendali ini tidak begitu buruk dan sebenarnya boleh berguna. Artikel ini akan meneroka != dan ==, menerangkan bagaimana mereka bekerja, dan membantu anda memahami mereka dengan lebih baik. !=

mata utama

• Memahami asas -asas: dan pengendali dalam JavaScript tidak semestinya jahat; == !=
Ketahui bila menggunakan yang mana:
• gunakan dan untuk perbandingan jenis dan nilai langsung tanpa pemutus, yang lebih jelas dan biasanya disyorkan untuk mengelakkan hasil yang tidak dijangka. Gunakan === dan !== apabila anda perlu membuang atau membandingkan nilai -nilai yang jenisnya boleh berubah secara dinamik. == !=
Ketahui peraturan cast:
• Biasa dengan bagaimana JavaScript membuang jenis semasa dan perbandingan, untuk meramalkan hasil dengan lebih tepat dan mengelakkan perangkap biasa. == !=
Terokai contoh praktikal:
• menggali contoh -contoh untuk melihat bagaimana dan dijalankan dalam pelbagai senario, seperti membandingkan rentetan kepada nombor atau objek kepada nilai asal, untuk menyatukan pemahaman. == !=
Jangan takut, tetapi berhati -hati:
• walaupun dan tidak menakutkan, mereka memerlukan pemahaman yang baik tentang peraturan jenis JavaScript untuk menjadi berkesan dan selamat dalam kod menggunakannya Secara tempatan. == !=

bermasalah

dan pengendali == != bahasa JavaScript mengandungi dua set pengendali kesamaan:

dan

, dan === dan !==. Memahami mengapa terdapat dua set pengendali kesamaan dan di mana situasi untuk menggunakan pengendali yang menjadi sumber kekeliruan bagi ramai orang. Pengendali == dan != tidak sukar difahami. Apabila kedua -dua jenis operan adalah sama dan nilai -nilai adalah sama, === pulangan !== dan === pulangan true. Walau bagaimanapun, apabila nilai atau jenis berbeza, !== pulangan false, === pulangan false. Pengendali !== dan true berkelakuan sama apabila kedua -dua jenis operan adalah sama. Walau bagaimanapun, apabila jenisnya berbeza, JavaScript membuang satu operan == ke jenis lain untuk menjadikan operan serasi sebelum perbandingan. Hasilnya sering mengelirukan, seperti berikut: != Kerana hanya terdapat dua nilai boolean yang mungkin, anda mungkin berfikir bahawa salah satu ungkapan harus dikira sebagai

. Walau bagaimanapun, mereka semua dikira sebagai

"this_is_true" == false // false
"this_is_true" == true  // false

. Kekeliruan tambahan berlaku apabila anda mengandaikan bahawa hubungan lulus (jika A adalah sama dengan B dan B adalah sama dengan C) harus dikenakan:

"this_is_true" == false // false
"this_is_true" == true  // false

Contoh ini menunjukkan bahawa == tidak mempunyai transitivenes. Jika rentetan kosong sama dengan nombor 0, dan jika nombor 0 adalah sama dengan rentetan yang terdiri daripada aksara 0, rentetan kosong harus sama dengan rentetan yang terdiri daripada 0. Tetapi itu tidak berlaku. Apabila jenis yang tidak serasi ditemui apabila membandingkan operan melalui == atau !=, JavaScript membuang satu jenis ke yang lain untuk menjadikannya setanding. Sebaliknya, apabila menggunakan === dan !==, ia tidak pernah melakukan jenis cast (yang membawa kepada peningkatan sedikit prestasi). Oleh kerana jenis yang berbeza, === selalu mengembalikan false dalam contoh kedua. Memahami peraturan yang mengawal bagaimana JavaScript membuang operan kepada pelbagai jenis supaya kedua -dua jenis operan serasi sebelum menggunakan == dan != dapat membantu anda menentukan kapan lebih baik menggunakan == dan !=, dan mempunyai keyakinan dalam menggunakan pengendali ini. Dalam bahagian seterusnya, kami akan meneroka peraturan pelakon yang digunakan dengan pengendali == dan !=.

Bagaimanakah

== dan != berfungsi?

Cara terbaik untuk mengetahui bagaimana kerja

dan == adalah untuk mengkaji spesifikasi bahasa ECMAScript. Bahagian ini memberi tumpuan kepada ECMAScript 262. Seksyen 11.9 Spesifikasi memperkenalkan pengendali kesamaan. Pengendali != dan == muncul dalam pengeluaran sintaks != dan EqualityExpression. (Tidak seperti generasi pertama, generasi kedua mengelakkan pengendali EqualityExpressionNoIn.) Mari kita periksa generasi in yang ditunjukkan di bawah. EqualityExpression

'' == 0   // true
0 == '0' // true
'' == '0' // false

Menurut generasi ini, ungkapan yang sama adalah sama ada ungkapan relasi, atau ungkapan yang sama yang sama dengan ekspresi hubungan, atau ungkapan yang sama yang tidak sama dengan ekspresi hubungan, dan lain -lain. (Saya terlepas pandang

dan ==, yang tidak berkaitan dengan artikel ini.) Seksyen 11.9.1 memberikan maklumat berikut mengenai cara != berfungsi: === !== == Formula Pengeluaran

dikira seperti berikut:

EqualityExpression : EqualityExpression == RelationalExpression biarkan

menjadi hasil pengiraan

.
1. lref biarkan EqualityExpression be
.
2. lval biarkan GetValue(lref) menjadi hasil pengiraan
.
3. rref biarkan RelationalExpression be
.
4. rval Mengembalikan hasil melakukan perbandingan kesamaan abstrak GetValue(rref). (Lihat 11.9.3.)
5. rval == lval Seksyen 11.9.2 Menyediakan maklumat yang sama tentang cara
berfungsi:

Formula Pengeluaran != dikira seperti berikut:

1. biarkan lref menjadi hasil pengiraan EqualityExpression.
2. biarkan lval be GetValue(lref).
3. biarkan rref menjadi hasil pengiraan RelationalExpression.
4. biarkan rval be GetValue(rref).
5. biarkan r menjadi hasil daripada melakukan perbandingan kesamaan abstrak rval != lval. (Lihat 11.9.3.)
jika
6. adalah r, kembali true. Jika tidak, kembali false. true

dan lref adalah rujukan di sebelah kiri dan kanan rref dan == pengendali. Setiap rujukan dihantar kepada fungsi dalaman != untuk mengembalikan nilai yang sepadan. Inti bagaimana kerja GetValue() dan == ditentukan oleh algoritma perbandingan kesamaan abstrak, yang diberikan dalam Seksyen 11.9.3: !=

Bandingkan

, di mana x == y dan x adalah nilai, menghasilkan y atau true. Perbandingan ini dijalankan seperti berikut: false

1. jika Type(x) sama dengan Type(y), maka
   1. jika Type(x) adalah Undefined, kembali true.
   2. jika Type(x) adalah Null, kembali true.
   3. jika Type(x) adalah Number, maka
      1. jika x adalah NaN, kembali false.
      2. jika y adalah NaN, kembali false.
      3. Jika x dan y adalah nilai berangka yang sama, kembali true.
      4. jika x adalah 0 dan y adalah -0, kembali true.
      5. jika x adalah -0 dan y adalah 0, maka true akan dikembalikan.
      6. kembali false.
   4. jika Type(x) adalah String, jika x dan y betul -betul urutan watak yang sama (panjang yang sama dan aksara yang sama dalam kedudukan yang sama), maka true dikembalikan. Jika tidak, kembali false.
   5. jika Type(x) adalah Boolean, maka jika x dan y kedua -duanya true atau kedua -duanya false, kemudian kembali true. Jika tidak, kembali false.
   6. Jika x dan y merujuk kepada objek yang sama, kembali true. Jika tidak, kembali false.
2. jika x adalah null dan y adalah undefined, kemudian kembali true.
3. jika x adalah undefined dan y adalah null, kemudian kembali true.
4. jika Type(x) adalah Number dan Type(y) adalah String, hasil perbandingan x == ToNumber(y) dikembalikan.
5. jika Type(x) adalah String dan Type(y) adalah Number, hasil perbandingan ToNumber(x) == y dikembalikan.
6. Jika Type(x) adalah Boolean, hasil perbandingan ToNumber(x) == y dikembalikan.
7. Jika Type(y) adalah Boolean, hasil perbandingan x == ToNumber(y) dikembalikan.
8. jika Type(x) adalah String atau Number dan Type(y) adalah Object, hasil perbandingan x == ToPrimitive(y) dikembalikan.
9. jika Type(x) adalah Object dan Type(y) adalah String atau Number, hasil perbandingan ToPrimitive(x) == y dikembalikan.
10. kembali false.

Langkah 1 Jenis pengendali adalah sama apabila dilaksanakan dalam algoritma ini. Ia menunjukkan bahawa undefined sama dengan undefined, dan null sama dengan null.Ia juga menunjukkan bahawa tiada sama dengan NaN (bukan nombor), dua nilai yang sama adalah sama, 0 sama dengan -0, dua rentetan dengan panjang dan urutan yang sama adalah sama, true sama dengan true, false sama dengan false, dan dua rujukan kepada objek yang sama adalah sama. Langkah 2 dan 3 menunjukkan mengapa null != undefined kembali false. JavaScript menganggap nilai -nilai ini sama. Bermula dari langkah 4, algoritma menjadi menarik. Langkah ini memberi tumpuan kepada kesaksamaan antara nilai Number. Apabila pengendali pertama adalah String dan operan kedua adalah Number, operan kedua ditukar kepada String melalui fungsi dalaman ToNumber(). Ekspresi Number bermaksud rekursi; Langkah 5 bersamaan dengan langkah 4, tetapi pengendali pertama mempunyai jenis x == ToNumber(y) dan mesti ditukar kepada jenis String. Langkah 6 dan 7 Tukar operand boolean ke jenis Number dan rekursif. Jika operan lain adalah boolean, ia akan ditukar kepada Number pada masa akan datang algoritma ini dilaksanakan, yang akan berulang lagi. Dari sudut pandangan prestasi, anda mungkin ingin memastikan kedua -dua operan adalah jenis Boolean untuk mengelakkan dua langkah rekursif. Langkah 9 menunjukkan bahawa jika jenis mana -mana pengendali adalah Number, operan ditukar kepada nilai asal melalui fungsi dalaman Object, dan algoritma secara rekursif. Akhirnya, algoritma menganggap bahawa kedua -dua pengendali tidak sama dan pulangan ToPrimitive() dalam langkah 10. Walaupun terperinci, algoritma perbandingan kesamaan abstrak agak mudah difahami. Walau bagaimanapun, ia merujuk sepasang fungsi dalaman false dan ToNumber(), yang kerja dalamannya perlu terdedah untuk memahami sepenuhnya algoritma. Fungsi ToPrimitive() menukarkan parameternya ke ToNumber() dan diterangkan dalam Bahagian 9.3. Senarai berikut meringkaskan kemungkinan parameter bukan angka dan nilai pulangan yang setara: Number

• Jika parameter itu Undefined, kembali NaN.
• Jika parameter itu Null, kembali 0.
• Jika parameter adalah nilai boolean true, kembali 1. Jika parameter adalah nilai boolean false, kembali 0.
• Jika jenis parameter adalah Number, parameter input dikembalikan - tiada penukaran.
• Jika jenis parameter adalah String, maka seksyen 9.3.1 "Tonumber jenis rentetan" digunakan. Mengembalikan nilai yang sepadan dengan parameter rentetan yang ditunjukkan oleh sintaks. Jika parameter tidak sepadan dengan sintaks yang ditunjukkan, kembali NaN. Sebagai contoh, parameter "XYZ" menyebabkan pulangan NaN. Tambahan pula, parameter "29" menghasilkan pulangan 29.
• Jika jenis parameter adalah Object, gunakan langkah -langkah berikut:
  1. biarkan primValue be ToPrimitive(输入参数, 提示Number).
  2. kembali ToNumber(primValue).

Fungsi

ToPrimitive() menerima parameter input dan parameter pilihan PreferredType. Parameter input ditukar kepada jenis bukan objek. Jika objek boleh ditukar kepada pelbagai jenis primitif, ToPrimitive() gunakan pilihan PreferredType prompt untuk bias jenis pilihan. Penukaran dijalankan seperti berikut:

1. Jika parameter input adalah Undefined, parameter input (Undefined) dikembalikan - tiada penukaran.
2. Jika parameter input adalah Null, parameter input (Null) dikembalikan - tiada penukaran.
3. Jika jenis parameter input adalah Boolean, kembalikan parameter input - tiada penukaran.
4. Jika jenis parameter input adalah Number, kembalikan parameter input - tiada penukaran.
5. Jika jenis parameter input adalah String, kembalikan parameter input - tiada penukaran.
6. Jika jenis parameter input adalah Object, nilai lalai yang sepadan dengan parameter input dikembalikan. Ambil nilai lalai objek dengan memanggil kaedah [[DefaultValue]] objek PreferredType dan lulus prompt [[DefaultValue]] pilihan. Tingkah laku
ditakrifkan dalam Seksyen 8.12.8 untuk semua objek ECMAScript asli.

== Bahagian ini memperkenalkan banyak teori. Dalam bahagian seterusnya, kami akan beralih kepada amalan dengan menyediakan pelbagai ungkapan yang melibatkan != dan

dan secara beransur -ansur menyelesaikan langkah -langkah algoritma.

Memahami Kembar Evil

== Sekarang kita telah memahami bagaimana != dan true berfungsi mengikut spesifikasi ECMAScript, marilah kita mengambil kesempatan daripada pengetahuan ini dengan meneroka pelbagai ungkapan yang melibatkan pengendali ini. Kami akan berjalan melalui cara menilai ungkapan ini dan mengetahui mengapa mereka false atau

. Untuk contoh pertama saya, pertimbangkan pasangan ungkapan berikut yang diperkenalkan berhampiran permulaan artikel:

"this_is_true" == false // false
"this_is_true" == true  // false

Ikuti algoritma perbandingan kesamaan abstrak untuk menilai ungkapan ini mengikut langkah -langkah berikut:

1. Langkau langkah 1 kerana jenisnya berbeza: typeof "this_is_true" mengembalikan "rentetan", sementara typeof false atau typeof true mengembalikan "boolean".
2. Langkau Langkah 2 hingga 6 yang tidak berkenaan kerana mereka tidak sepadan dengan jenis operan. Walau bagaimanapun, langkah 7 terpakai kerana parameter yang betul mempunyai jenis Boolean. Ekspresi ditukar kepada "this_is_true" == ToNumber(false) dan "this_is_true" == ToNumber(true).
3. ToNumber(false) pulangan 0, ToNumber(true) pulangan 1, yang memudahkan ungkapan ke "this_is_true" == 0 dan "this_is_true" == 1 masing -masing. Pada masa ini algoritma secara rekursif.
4. Langkau Langkah 1 hingga 4 yang tidak berkenaan kerana mereka tidak sepadan dengan jenis operan. Walau bagaimanapun, langkah 5 terpakai kerana jenis operan kiri adalah String dan jenis pengendali kanan adalah Number. Ekspresi ditukar kepada ToNumber("this_is_true") == 0 dan ToNumber("this_is_true") == 1.
5. ToNumber("this_is_true") kembali NaN, yang memudahkan ekspresi ke NaN == 0 dan NaN == 1 masing -masing. Pada masa ini algoritma secara rekursif.
6. pergi ke langkah 1, kerana jenis NaN, 0 dan 1 adalah semua Number. Langkau Langkah 1.A dan 1.B yang tidak berkenaan. Walau bagaimanapun, langkah 1.c.i terpakai kerana operan kiri adalah NaN. Algoritma kini kembali false (NaN tidak sama dengan apa -apa, termasuk dirinya sendiri) sebagai nilai setiap ungkapan asal dan backtracks timbunan untuk keluar dari rekursi sepenuhnya.

Contoh kedua saya (berdasarkan penjelasan makna kehidupan dalam "Panduan Galaxy Wandering") membandingkan objek dengan nombor dengan == dan mengembalikan true:

"this_is_true" == false // false
"this_is_true" == true  // false

Langkah -langkah berikut menunjukkan bagaimana JavaScript menggunakan algoritma perbandingan kesamaan abstrak untuk mendapatkan true sebagai nilai ungkapan:

1. Langkau Langkah 1 hingga 8 yang tidak berkenaan kerana mereka tidak sepadan dengan jenis operan. Walau bagaimanapun, langkah 9 terpakai kerana jenis operan kiri adalah Object dan jenis pengendali kanan adalah Number. Ekspresi ditukar kepada ToPrimitive(lifeAnswer) == 42.
2. ToPrimitive() Panggil lifeAnswer kaedah dalaman [[DefaultValue]], tanpa segera. Menurut Seksyen 8.12.8 spesifikasi ECMAScript 262, [[DefaultValue]] memanggil kaedah toString(), yang mengembalikan "42". Ekspresi ditukar kepada "42" == 42, dan algoritma adalah rekursif.
3. Langkau Langkah 1 hingga 4 yang tidak berkenaan kerana mereka tidak sepadan dengan jenis operan. Walau bagaimanapun, langkah 5 terpakai kerana jenis operan kiri adalah String dan jenis pengendali kanan adalah Number. Ekspresi ditukar kepada ToNumber("42") == 42.
4. ToNumber("42") mengembalikan 42, dan ungkapan ditukar kepada 42 == 42. Algoritma ini berulang dan melaksanakan langkah 1.C.III. Kerana angka -angka itu sama, true dikembalikan dan diperluas secara rekursif.

Untuk contoh terakhir saya, mari kita ketahui mengapa urutan berikut tidak menunjukkan transitiveness, di mana perbandingan ketiga akan kembali true bukan false:

"this_is_true" == false // false
"this_is_true" == true  // false

Langkah -langkah berikut menunjukkan bagaimana JavaScript menggunakan algoritma perbandingan kesamaan abstrak untuk mendapatkan true sebagai nilai '' == 0.

1. Jalankan langkah 5, menghasilkan ToNumber('') == 0, yang ditukar kepada 0 == 0, dan algoritma secara rekursif. (Seksyen 9.3.1 spesifikasi menyatakan bahawa stringnumericliteral ::: [kosong] 's mv [nilai matematik] adalah 0. Dengan kata lain, nilai rentetan kosong adalah 0.)
2. Jalankan Langkah 1.C.III, yang membandingkan 0 dengan 0 dan pulangan true (dan memperluaskan rekursi).

Langkah -langkah berikut menunjukkan bagaimana JavaScript menggunakan algoritma perbandingan kesamaan abstrak untuk mendapatkan true sebagai nilai 0 == '0':

1. Jalankan langkah 4, menghasilkan 0 == ToNumber('0'), yang ditukar kepada 0 == 0, dan algoritma secara rekursif.
2. Jalankan Langkah 1.C.III, yang membandingkan 0 dengan 0 dan pulangan true (dan memperluaskan rekursi).

Akhirnya, JavaScript melakukan langkah 1.D dalam algoritma perbandingan kesamaan abstrak untuk mendapatkan true sebagai nilai '' == '0'. Kerana kedua -dua rentetan mempunyai panjang yang berbeza (0 dan 1), kembali false.

Kesimpulan

Anda mungkin tertanya -tanya mengapa anda perlu bersusah payah menggunakan == dan !=. Lagipun, contoh -contoh sebelumnya telah menunjukkan bahawa pengendali ini mungkin lebih perlahan daripada pengendali === dan !== kerana jenis pemutus dan rekursi. Anda mungkin mahu menggunakan == dan != kerana dalam beberapa kes tidak ada kelebihan. Pertimbangkan contoh berikut: ===

"this_is_true" == false // false
"this_is_true" == true  // false

Pengendali

typeof mengembalikan nilai String. Kerana nilai String dibandingkan dengan nilai String yang lain ("objek"), tiada jenis pemutus berlaku, dan == adalah efisien seperti ===. Mungkin seorang pemula JavaScript yang tidak pernah menemui === akan mencari kod tersebut lebih jelas. Begitu juga, coretan kod berikut tidak memerlukan pemutus jenis (jenis kedua -dua operan adalah Number), jadi != adalah efisien seperti !==:

'' == 0   // true
0 == '0' // true
'' == '0' // false

Contoh -contoh ini menunjukkan bahawa == dan != sesuai untuk perbandingan yang tidak memerlukan pemutus. Apabila jenis pengendali adalah berbeza, === dan !== adalah pilihan terbaik kerana mereka kembali false daripada nilai -nilai yang tidak dijangka (mis. Jika jenis pengendali adalah sama, tidak ada sebab untuk tidak menggunakan false == "" dan true. Mungkin sudah tiba masanya untuk berhenti takut kepada kembar jahat, dan apabila anda memahami mereka, mereka kurang jahat. == !=

FAQs untuk JavaScript Equality and Comparison Operators (FAQs)

Apakah perbezaan antara

dan

dalam JavaScript? == === dalam JavaScript,

dan

adalah pengendali perbandingan. Walau bagaimanapun, mereka berbeza dengan cara mereka membandingkan nilai. Pengendali == (juga dikenali sebagai pengendali kesamaan longgar) melakukan jenis pemutus sebelum perbandingan. Ini bermakna jika anda membandingkan dua jenis nilai, JavaScript akan cuba menukar satu jenis ke yang lain sebelum melakukan perbandingan. Sebaliknya, pengendali === (dipanggil pengendali kesamaan yang ketat) tidak melakukan pemutus jenis. Ia membandingkan nilai dan jenis pada masa yang sama, yang bermaksud bahawa jika kedua -dua jenis nilai berbeza, JavaScript akan menganggapnya tidak sama rata. == === Kenapa saya harus menggunakan

bukan

dalam JavaScript? === == umumnya disyorkan untuk menggunakan

bukannya

dalam JavaScript, kerana ia memberikan perbandingan yang lebih ketat, yang bermaksud ia tidak melakukan jenis cast dan cek untuk nilai dan jenis. Ini dapat membantu mengelakkan hasil yang tidak dijangka apabila membandingkan pelbagai jenis nilai. Sebagai contoh, apabila menggunakan ===, JavaScript menganggap nombor 0 dan rentetan kosong "" sama, kerana ia menukarkan jenis sebelum perbandingan. Walau bagaimanapun, dengan menggunakan ==, mereka akan dianggap tidak sama rata kerana mereka mempunyai pelbagai jenis. == === Apakah jenis pelakon dalam JavaScript?

Taipkan Cast dalam JavaScript merujuk kepada nilai -nilai yang ditukar secara automatik atau secara tersirat dari satu jenis data ke yang lain. Ini berlaku apabila pengendali digunakan untuk pelbagai jenis operan atau apabila beberapa jenis diperlukan. Sebagai contoh, apabila menggunakan pengendali kesamaan longgar (), JavaScript akan cuba menukar operan kepada jenis umum sebelum membuat perbandingan.

Bagaimanakah JavaScript mengendalikan perbandingan objek?

Dalam JavaScript, objek dibandingkan dengan rujukan, bukan dengan nilai. Ini bermakna walaupun dua objek mempunyai sifat dan nilai yang sama, mereka tidak dianggap sama kerana mereka merujuk kepada objek yang berbeza dalam ingatan. Satu -satunya kes di mana objek dianggap sama adalah bahawa mereka merujuk kepada objek yang sama.

Apakah perbezaan antara

== dan != dalam JavaScript?

== dan != adalah pengendali perbandingan dalam JavaScript. Pengendali == memeriksa sama ada nilai kedua -dua pengendali adalah sama, dan melakukan jenis cast jika perlu. Sebaliknya, pengendali != memeriksa sama ada nilai kedua -dua operan tidak sama, dan melakukan jenis cast jika perlu.

Apakah perbezaan antara

=== dan !== dalam JavaScript?

=== dan !== adalah pengendali perbandingan dalam JavaScript. Pengendali === memeriksa sama ada nilai kedua -dua pengendali adalah sama, dengan mengambil kira kedua -dua nilai dan jenis. Sebaliknya, pengendali !== memeriksa sama ada nilai kedua -dua operan tidak sama, dengan mengambil kira kedua -dua nilai dan jenis.

Bagaimana membandingkan dua tatasusunan dalam JavaScript?

Dalam JavaScript, tatasusunan adalah objek, berbanding dengan rujukan, bukan dengan nilai. Ini bermakna walaupun dua tatasusunan mengandungi unsur yang sama dalam urutan yang sama, mereka tidak dianggap sama kerana mereka merujuk kepada objek yang berbeza dalam ingatan. Untuk membandingkan dua tatasusunan dengan kandungan mereka, anda perlu membandingkan setiap elemen secara berasingan.

Bagaimanakah JavaScript mengendalikan perbandingan antara null dan undefined?

dalam JavaScript, null dan undefined dianggap longgar sama (==) kerana kedua -duanya mewakili nilai yang hilang. Walau bagaimanapun, mereka tidak sama sama (===) kerana mereka mempunyai pelbagai jenis.

Apakah urutan keutamaan pengendali perbandingan dalam JavaScript?

Di JavaScript, pengendali perbandingan mempunyai tahap keutamaan yang sama. Mereka dikira dari kiri ke kanan. Walau bagaimanapun, adalah penting untuk diperhatikan bahawa mereka mempunyai keutamaan yang lebih rendah daripada pengendali aritmetik dan bitwise, tetapi lebih tinggi daripada pengendali logik.

Bolehkah saya menggunakan pengendali perbandingan dengan rentetan dalam javascript?

Ya, anda boleh menggunakan pengendali perbandingan dengan rentetan dalam JavaScript. JavaScript menggunakan perintah leksikal (kamus) apabila membandingkan rentetan. Walau bagaimanapun, adalah penting untuk diperhatikan bahawa huruf modal dianggap "kecil" daripada huruf kecil kerana mereka mempunyai nilai ASCII yang lebih kecil.

Atas ialah kandungan terperinci DON ' T Takut Kembar Evil - Sitepoint. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!