Operator mana yang sama (== vs ===) yang akan digunakan dalam perbandingan JavaScript?

Saya menggunakan JSLint untuk melewati JavaScript, dan ia mengembalikan banyak kalimat untuk menggantikan == (dua tanda sama dengan) dengan === (tiga tanda sama dengan) ketika Anda melakukan sesuatu seperti perbandingan idSele_UNVEHtype.value.length == 0 di dalam operator if .

Apakah ada keuntungan kinerja untuk mengganti == ke === ?

Setiap peningkatan kinerja akan disambut baik karena ada banyak operator pembanding.

Jika konversi jenis tidak terjadi, apakah keuntungan akan dibandingkan dengan == ?

5673
11 дек. Diatur oleh bcasp 11 Des 2008-12-11 17:19 '08 pada 17:19 2008-12-11 17:19
ответ 51 jawaban
  • 1
  • 2

Operator identitas ( === ) berperilaku identik dengan operator persamaan ( == ), kecuali bahwa konversi jenis tidak dilakukan, dan jenisnya harus sama agar dianggap sama.

Referensi: Tutorial Javascript: Operator Perbandingan

Operator == akan membandingkan kesetaraan setelah melakukan konversi jenis apa pun yang diperlukan. Operator === tidak akan melakukan konversi, jadi jika kedua nilai tidak cocok, maka === hanya akan mengembalikan false . Keduanya sama-sama cepat.

Douglas Crockford, javascript yang sangat baik: bagian yang baik ,

Dalam JavaScript, ada dua set operator persamaan: === dan !== , dan si kembar jahatnya == dan != . Yang bagus bekerja seperti yang Anda harapkan. Jika dua operan dari jenis yang sama memiliki nilai yang sama, maka === menciptakan true dan !== menghasilkan false . Si kembar jahat melakukan hal yang benar ketika operan memiliki tipe yang sama, tetapi jika mereka memiliki tipe yang berbeda, mereka mencoba untuk menegakkan nilai. aturan yang mereka buat itu rumit dan tidak dapat diatasi. Berikut ini beberapa kasus menarik:

 '' == '0' // false 0 == '' // true 0 == '0' // true false == 'false' // false false == '0' // true false == undefined // false false == null // false null == undefined // true ' \t\r\n ' == 0 // true 

Kurangnya transitivitas mengkhawatirkan. Saran saya adalah jangan pernah menggunakan si kembar jahat. Sebagai gantinya, selalu gunakan === dan !== . Semua perbandingan di atas menunjukkan false dengan operator === .


Perbarui:

Poin yang bagus diajukan oleh @Casebash di komentar dan di @Phillipe Laybaert mengenai tipe referensi. Untuk tipe referensi, == dan === bertindak secara konsisten satu sama lain (kecuali dalam kasus khusus).

 var a = [1,2,3]; var b = [1,2,3]; var c = { x: 1, y: 2 }; var d = { x: 1, y: 2 }; var e = "text"; var f = "te" + "xt"; a == b // false a === b // false c == d // false c === d // false e == f // true e === f // true 

Kasus khusus adalah perbandingan literal dengan objek yang mengevaluasi literal yang sama karena valueOf toString atau valueOf . Sebagai contoh, pertimbangkan untuk membandingkan string literal dengan objek string yang dibuat oleh konstruktor String .

 "abc" == new String("abc") // true "abc" === new String("abc") // false 

Di sini, operator == memeriksa nilai dua objek dan mengembalikan true , tetapi === melihat bahwa mereka tidak dari tipe yang sama dan mengembalikan false . Yang mana yang benar? Ini benar-benar tergantung pada apa yang Anda coba bandingkan. Saran saya adalah untuk sepenuhnya menghindari pertanyaan dan tidak menggunakan konstruktor String untuk membuat objek string.

Referensi
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

5840
11 дек. Balas diberikan oleh Bill the Lizard pada 11 Des 2008-12-11 17:25 '08 pukul 17:25 2008-12-11 17:25

Menggunakan operator == (Kesetaraan)

 true == 1; //true, because 'true' is converted to 1 and then compared "2" == 2; //true, because "2" is converted to 2 and then compared 

Menggunakan operator === (Identitas)

 true === 1; //false "2" === 2; //false 

Ini disebabkan oleh fakta bahwa operator persamaan == memiliki tipe paksaan , yang berarti bahwa juru bahasa secara implisit mencoba untuk mengkonversi nilai sebelum perbandingan.

Di sisi lain, operator Identity === tidak melakukan tipe paksaan dan, karenanya, tidak mengonversi nilai saat membandingkan.

1016
11 дек. Jawabannya diberikan oleh Andreas Grech 11 Desember. 2008-12-11 17:33 '08 pada 17:33 2008-12-11 17:33

Dalam jawaban di sini, saya tidak membaca apa pun tentang apa artinya sama . Beberapa orang akan mengatakan bahwa === berarti sama dan berjenis sama , tetapi tidak. Bahkan, ini berarti bahwa kedua operan merujuk ke objek yang sama atau, dalam kasus tipe nilai , memiliki nilai yang sama .

Jadi mari kita ambil kode berikut:

 var a = [1,2,3]; var b = [1,2,3]; var c = a; var ab_eq = (a === b); // false (even though a and b are the same type) var ac_eq = (a === c); // true 

Sama di sini:

 var a = { x: 1, y: 2 }; var b = { x: 1, y: 2 }; var c = a; var ab_eq = (a === b); // false (even though a and b are the same type) var ac_eq = (a === c); // true 

Atau bahkan:

 var a = { }; var b = { }; var c = a; var ab_eq = (a === b); // false (even though a and b are the same type) var ac_eq = (a === c); // true 

Perilaku ini tidak selalu jelas. Ada lebih banyak cerita daripada menjadi sama dan berjenis sama.

Aturan:

Untuk jenis nilai (angka):
a === b mengembalikan true jika a dan b memiliki nilai yang sama dan memiliki tipe yang sama

Untuk jenis referensi:
a === b mengembalikan true jika a dan b merujuk ke objek yang sama.

Untuk string:
a === b mengembalikan true jika a dan b keduanya adalah string dan mengandung karakter yang sama.


Strings: case khusus ...

String bukan tipe nilai, tetapi dalam Javascript mereka berperilaku seperti tipe nilai, jadi mereka akan "sama" ketika karakter dalam string adalah sama dan ketika mereka memiliki panjang yang sama (seperti yang dijelaskan dalam aturan ketiga)

Sekarang menjadi menarik:

 var a = "12" + "3"; var b = "123"; alert(a === b); // returns true, because strings behave like value types 

Tapi bagaimana dengan ini?

 var a = new String("123"); var b = "123"; alert(a === b); // returns false !! (but they are equal and of the same type) 

Saya pikir string berperilaku seperti tipe nilai? Yah, itu tergantung pada siapa yang kamu tanyakan ... Dalam hal ini, a dan b bukan tipe yang sama. a adalah tipe Object , dan b adalah tipe string . Ingatlah bahwa membuat objek string menggunakan konstruktor string menciptakan sesuatu seperti Object , yang berperilaku seperti string.

564
05 июня '09 в 22:11 2009-06-05 22:11 membalas Philippe Leybaert pada 05 Juni 2009 di 10:11 2009-06-05 22:11

Representasi grafis yang menarik dari perbandingan kesetaraan antara == dan === .

Sumber: http://dorey.github.io/JavaScript-Equality-Table/


var1 === var2

Saat menggunakan === untuk menguji kesetaraan JavaScript, semuanya seperti apa adanya. Tidak ada yang dikonversi sebelum evaluasi.

2019

553
05 мая '14 в 8:21 2014-05-05 08:21 jawabannya diberikan oleh SNag pada 05 Mei '14 di 8:21 2014-05-05 08:21

Izinkan saya menambahkan tip ini:

Jika ragu, baca spesifikasinya !

ECMA-262 adalah spesifikasi bahasa skrip di mana JavaScript adalah dialek. Tentu saja, dalam praktiknya adalah penting bagaimana peramban yang paling penting berperilaku, daripada definisi esoteris tentang bagaimana sesuatu harus ditangani. Tetapi sangat membantu untuk memahami mengapa String baru ("a")! == "a" .

Tolong izinkan saya menjelaskan cara membaca spesifikasi untuk mengklarifikasi masalah ini. Saya melihat bahwa dalam topik yang sangat lama ini tidak ada yang mendapat jawaban untuk efek yang sangat aneh. Jadi, jika Anda dapat membaca spesifikasinya, itu akan banyak membantu Anda dalam profesi Anda. Ini adalah keterampilan yang didapat. Jadi silakan.

Menemukan file PDF untuk === membawa saya ke halaman 56 dari spesifikasi: 11.9.4. Operator Sama Ketat (===) , dan setelah melewati spesifikasi, saya menemukan:

11.9.6 Algoritma untuk Perbandingan Kesetaraan Yang Ketat
Membandingkan x === y, di mana x dan y adalah nilai, menciptakan true atau false . Perbandingan semacam itu dilakukan sebagai berikut:
1. Jika Tipe (x) berbeda dari Tipe (y), kembalikan salah .
2. Jika tipe (x) tidak terdefinisi, kembalikan benar .
3. Jika Tipe (x) kosong, kembalikan benar .
4. Jika Ketik (x) bukan angka, lanjutkan ke > 5. Jika x adalah NaN , kembalikan salah .
6. Jika y adalah NaN , kembalikan salah .
7. Jika x adalah nilai numerik yang sama dengan y, kembalikan benar .
8. Jika x adalah +0 dan y adalah -0, kembalikan true .
9. Jika x adalah -0 dan y adalah +0, kembalikan true .
10. Kembali salah .
11. Jika Tipe (x) adalah String, kembalikan benar jika x dan y adalah urutan karakter yang sama (panjang yang sama dan karakter yang sama di posisi yang sesuai); jika tidak, kembalikan salah .
12. Jika Tipe (x) adalah boolean, kembalikan benar jika x dan y keduanya benar atau keduanya salah ; jika tidak, kembalikan salah .
13. Kembalikan benar jika x dan y milik objek yang sama atau berhubungan dengan objek yang terhubung satu sama lain (lihat 13.1.2). Kalau tidak, kembalikan salah .

Tahap 11 menarik. Ya, string diperlakukan sebagai tipe nilai. Tapi ini tidak menjelaskan mengapa String baru ("a")! == "a" . Apakah kita memiliki browser non-ECMA-262?

Tidak secepat itu!

Periksa jenis operan. Cobalah sendiri dengan membungkusnya dalam typeof () . Saya menemukan bahwa String baru ("a") adalah objek, dan >false jika jenisnya berbeda.

Jika Anda bertanya-tanya mengapa String baru ("a") tidak mengembalikan string, bagaimana dengan beberapa latihan yang membaca spesifikasi? Selamat bersenang-senang!


Aidiakapi menulis ini dalam komentar di bawah ini:

Dari spesifikasinya

11.2.2 Operator baru :

Jika tipe (konstruktor) bukan objek, naikkan pengecualian TypeError.

Dengan kata lain, jika String bukan dari tipe Object, itu tidak dapat digunakan dengan operator baru.

baru selalu mengembalikan objek, bahkan untuk konstruktor string . Dan sayangnya! Semantik nilai untuk string (lihat >

Dan ini akhirnya berarti: String baru ("a")! == "a" .

254
28 нояб. Jawabannya diberikan 28 nov. 2009-11-28 21:18 '09 pada 21:18 2009-11-28 21:18

Dalam PHP dan JavaScript, ini adalah operator kesetaraan yang ketat. Ini berarti akan membandingkan jenis dan nilai.

95
12 мая '10 в 15:58 2010-05-12 15:58 jawabannya diberikan oleh Shiki pada 12 Mei, '10 pada 15:58 2010-05-12 15:58

Saya mengujinya di Firefox menggunakan Firebug menggunakan kode berikut:

 console.time("testEquality"); var n = 0; while(true) { n++; if(n==100000) break; } console.timeEnd("testEquality"); 

dan

 console.time("testTypeEquality"); var n = 0; while(true) { n++; if(n===100000) break; } console.timeEnd("testTypeEquality"); 

Hasil saya (diperiksa lima kali dan rata-rata):

 ==: 115.2 ===: 114.4 

Jadi, saya akan mengatakan bahwa sedikit perbedaan (ini lebih dari 100.000 iterasi, ingat) dapat diabaikan. Performa bukan penyebab === . Jenis keamanan (well, seaman Anda akan javascript), dan kualitas kode.

91
25 дек. Jawabannya diberikan oleh Simon Scarfe pada 25 Desember. 2008-12-25 14:17 '08 pukul 14:17 2008-12-25 14:17

Dalam JavaScript, ini berarti nilai dan jenis yang sama.

Sebagai contoh

 4 == "4" // will return true 

tapi

 4 === "4" // will return false 
88
12 мая '10 в 15:58 2010-05-12 15:58 jawabannya diberikan oleh Dimitar pada 12 Mei '10 pada 15:58 2010-05-12 15:58

Operator === disebut operator perbandingan ketat, ini berbeda dari operator == .

Ambil 2 vars a dan b.

Untuk "a == b" untuk mengevaluasi kebenaran a dan b harus menjadi satu nilai .

Dalam kasus "a === b" a dan b harus memiliki nilai yang sama , serta jenis yang sama untuk mengevaluasi kebenaran.

Ambil contoh berikut

 var a = 1; var b = "1"; if (a == b) //evaluates to true as a and b are both 1 { alert("a == b"); } if (a === b) //evaluates to false as a is not the same type as b { alert("a === b"); } 

Kesimpulannya ; Menggunakan operator == dapat dinilai sebagai benar dalam situasi di mana Anda tidak menginginkannya, jadi menggunakan operator === akan lebih aman.

Dalam skenario penggunaan 90%, tidak masalah yang mana yang Anda gunakan, tetapi sangat membantu untuk mengetahui perbedaannya ketika Anda mendapatkan perilaku yang tidak terduga suatu hari.

77
11 дек. Jawabannya diberikan oleh Dokter Jones 11 Des. 2008-12-11 17:58 '08 pada pukul 5:58 sore 2008-12-11 17:58

Ia memeriksa apakah sisi yang sama sama dalam jenis dan nilai .

Contoh:

 '1' === 1 // will return "false" because 'string' is not a 'number' 

Contoh umum:

 0 == '' // will be "true", but it very common to want this check to be "false" 

Contoh umum lainnya adalah:

 null == undefined // returns "true", but in most cases a distinction is necessary 
70
12 мая '10 в 15:58 2010-05-12 15:58 jawabannya diberikan oleh vsync pada 12 Mei 10 di 15:58 2010-05-12 15:58

Mengapa == begitu tidak dapat diprediksi?

Apa yang Anda dapatkan ketika Anda membandingkan string kosong "" dengan angka 0 0 ?

<code> Truecode>

Ya, ini benar sesuai dengan == string kosong, dan angka nol adalah waktu yang sama.

Dan ini tidak berakhir di sini, yang lain:

  '0' == false//true Код> 

Banyak hal menjadi sangat aneh dengan array.

  [1] == true//true [] == false//true [[]] == false//true [0] == false//true Код> 

Kemudian lebih kurus dengan string

  [1,2,3] == '1,2,3'//true - ДЕЙСТВИТЕЛЬНО?! '\ r\n\t' == 0//true - Давай! Код> 

Semakin buruk:

Kapan tidak sama dengan?

  let A = ''//пустая строка пусть В = 0//нуль пусть C = '0'//нулевая строка A == B//true - ok... B == C//true - пока что так хорошо... A == C//** FALSE ** - Закручивание сюжета! Код> 

Biarkan saya katakan lagi:

  (A == B)(B == C)//true (A == C)//** FALSE ** Код> 

Dan ini hanya hal-hal gila yang Anda dapatkan dengan primitif.

Ini adalah tingkat kegilaan baru ketika Anda menggunakan == dengan objek.

Pada titik ini, Anda mungkin bertanya-tanya ...

Mengapa ini terjadi?

Bagus, karena tidak seperti "kesetaraan rangkap tiga" ( === ), yang hanya memeriksa apakah kedua nilai cocok.

== melakukan banyak hal lainnya .

Ini memiliki pemrosesan khusus untuk fungsi, pemrosesan khusus untuk nol, string, yang Anda panggil.

Itu menjadi sangat bodoh.

Bahkan, jika Anda mencoba untuk menulis fungsi yang melakukan apa yang dilakukannya == , itu akan terlihat seperti ini:

  function isEqual (x, y) {//если `==` были функцией   if (typeof y === typeof x) return y === x;   // обрабатываем null и undefined то же самое   var xIsNothing = (y === undefined) || (y === null);   var yIsNothing = (x === undefined) || (x === null);  если (xIsNothing || yIsNothing) возвращается (xIsNothing  yIsNothing);  if (typeof y === "function" || typeof x === "function" ) {   // если любое значение является строкой   // преобразовать функцию в строку и сравнить   if (typeof x === "string" ) {   return x === y.toString();   } else if (typeof y === "string" ) {   return x.toString() === y;   }   return false;   }  if (typeof x === "object" ) x = toPrimitive (x);   if (typeof y === "object" ) y = toPrimitive (y);   if (typeof y === typeof x) return y === x;  // конвертируем x и y в числа, если они еще не используют трюк +   if (typeof x! == "number" ) x = + x;   if (typeof y! == "number" ) y = + y;   // фактически реальный `==` еще более сложный, чем это, особенно в ES6   return x === y; } функция toPrimitive (obj) {   var value = obj.valueOf();   if (obj! == value) возвращаемое значение;   return obj.toString(); } Код> 

Jadi apa artinya ini?

Ini berarti bahwa == rumit.

Karena sulit, sulit untuk memahami apa yang akan terjadi ketika Anda menggunakannya.

Ini berarti Anda mungkin memiliki kesalahan.

Jadi moral dari cerita ...

Buat hidup Anda lebih mudah.

Gunakan === daripada == .

Akhirnya

68
09 авг. jawabannya diberikan oleh Luis Perez 09 Agustus. 2016-08-09 19:50 '16 pada 7:50 malam 2016-08-09 19:50

Diagram urutan eksekusi Javascript untuk kesetaraan / perbandingan '==='

2019

05 сент. jawabannya diberikan Samar Panda 05 sept. 2015-09-05 16:53 '15 pada 16:53 2015-09-05 16:53

Javascript === vs == .

 0==false // true 0===false // false, because they are of a different type 1=="1" // true, auto type coercion 1==="1" // false, because they are of a different type 
52
03 июля '13 в 7:08 2013-07-03 07:08 jawabannya diberikan oleh user2496033 03 Juli '13 pada 7:08 2013-07-03 07:08

Ini berarti kesetaraan tanpa pemaksaan tipe. Jenis pemaksaan berarti bahwa JavaScript tidak secara otomatis mengonversi tipe data lain menjadi tipe data string.

 0==false // true,although they are different types 0===false // false,as they are different types 2=='2' //true,different types,one is string and another is integer but javaScript convert 2 to string by using == operator 2==='2' //false because by using === operator ,javaScript do not convert integer to string 2===2 //true because both have same value and same types 
51
12 мая '10 в 15:59 2010-05-12 15:59 jawabannya diberikan oleh Pop Catalin pada 12 Mei, '10 pukul 15:59 2010-05-12 15:59

Dalam skrip tipikal tidak akan ada perbedaan dalam kinerja. Lebih penting lagi, fakta bahwa seribu "===" adalah 1 kilobyte lebih berat daripada seribu "==" :) JavaScript profiler dapat memberi tahu Anda jika ada perbedaan kinerja dalam kasus Anda.

Tetapi secara pribadi, saya akan melakukan apa yang JSLint tawarkan. Rekomendasi ini bukan karena masalah kinerja, tetapi karena pembatasan jenis ('\t\r\n' == 0) .

46
16 дек. balasan diberikan Konstantin 16 Des. 2008-12-16 17:29 '08 pada 17:29 2008-12-16 17:29

Operator perbandingan yang sama == bingung dan harus dihindari.

Jika Anda hidup dengan HAVE , ingat 3 hal berikut:

  • Ini bukan transitif: (a == b) dan (b == c) tidak menghasilkan (a == c)
  • Saling mengecualikan negasinya: (a == b) dan (a! = B) selalu memiliki nilai Boolean yang berlawanan dengan semua a dan b.
  • Jika ragu, hafal tabel kebenaran berikut:

TABEL OPERATOR YANG TEPAT DI JAVASCRIPT

  • Setiap baris dalam tabel adalah satu set 3 nilai yang sama "sama", yang berarti bahwa setiap 2 nilai dari mereka sama dengan menggunakan tanda == * sama dengan

** STRANGE: perhatikan bahwa dua nilai di kolom pertama tidak sama dalam arti ini. **

 '' == 0 == false // Any two values among these 3 ones are equal with the == operator '0' == 0 == false // Also a set of 3 equal values, note that only 0 and false are repeated '\t' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- '\r' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- '\n' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- '\t\r\n' == 0 == false // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- null == undefined // These two "default" values are not-equal to any of the listed values above NaN // NaN is not equal to any thing, even to itself. 
42
16 сент. balasan yang diberikan oleh CuongHuyTo 16 Sep 2011-09-16 17:25 '11 pada 17:25 2011-09-16 17:25

Hampir tidak ada perbedaan kinerja antara kedua operasi yang Anda gunakan. Tidak ada konversi tipe yang harus dilakukan, karena kedua parameter memiliki tipe yang sama. Kedua operasi akan memiliki perbandingan tipe diikuti oleh perbandingan nilai.

35
11 дек. balasan diberikan Sean 11 Des 2008-12-11 17:44 '08 pada 17:44 2008-12-11 17:44

Ya Itu penting.

Operator === dalam javascript memeriksa nilainya, serta jenisnya , di mana operator == cukup memeriksa nilainya (mengonversi jenis jika perlu) .

2019

35
14 нояб. Jawaban yang diberikan oleh Aniket Thakur 14 Nov 2014-11-14 09:02 '14 pukul 9:02 2014-11-14 09:02
Operator

=== memeriksa nilai serta jenis variabel untuk kesetaraan.

Operator

== hanya memeriksa nilai variabel untuk kesetaraan.

32
12 мая '10 в 16:03 2010-05-12 16:03 jawabannya diberikan oleh Niraj Choubey pada 12 Mei '10 pada 16:03 2010-05-12 16:03

Ini adalah tes tes yang ketat.

Ini bagus, terutama jika Anda memeriksa antara 0 dan false dan nol.

Misalnya, jika Anda memiliki:

 $a = 0; 

Lalu:

 $a==0; $a==NULL; $a==false; 

Semuanya kembali benar, dan Anda mungkin tidak menginginkannya. Misalkan Anda memiliki fungsi yang dapat mengembalikan indeks array 0 atau kesalahan salah. Jika Anda menandai kotak dengan "==" false, Anda bisa mendapatkan hasil yang membingungkan.

Jadi, dengan yang sama seperti di atas, tetapi tes yang ketat:

 $a = 0; $a===0; // returns true $a===NULL; // returns false $a===false; // returns false 
30
12 мая '10 в 16:19 2010-05-12 16:19 Jawaban diberikan kepada Daniel 12 Mei 10 di 16:19 2010-05-12 16:19

JSLint terkadang memberikan alasan tidak realistis untuk mengubah materi. === memiliki kinerja yang sama dengan == jika tipe sudah cocok.

Ini lebih cepat hanya jika tipe tidak cocok, dalam hal ini ia tidak mencoba untuk mengkonversi tipe, tetapi mengembalikan false.

Jadi, IMHO, JSLint dapat digunakan untuk menulis kode baru, tetapi optimasi berlebihan yang tidak berguna harus dihindari di semua biaya.

Artinya, tidak ada alasan untuk mengubah == menjadi === dalam sebuah tes, misalnya if (a == 'test') , ketika Anda mengetahuinya, karena suatu fakta hanya dapat berupa String.

Memodifikasi sejumlah besar kode dengan cara ini membutuhkan waktu dari pengembang dan pengulas dan tidak mencapai apa pun.

29
05 июня '12 в 10:53 2012-06-05 10:53 Balasan diberikan abu pada 05 Juni '12 di 10:53 2012-06-05 10:53

Adil

== berarti perbandingan antara operan dengan type conversion

=== berarti perbandingan antara operan tanpa type conversion

Konversi tipe dalam javaScript berarti bahwa javaScript secara otomatis mengkonversi tipe data lain menjadi tipe data string.

Sebagai contoh:

 123=='123' //will return true, because JS convert integer 123 to string '123' //as we used '==' operator 123==='123' //will return false, because JS do not convert integer 123 to string //'123' as we used '===' operator 
28
ответ дан Amit 20 марта '15 в 8:05 2015-03-20 08:05