Koji je operator jednak (== vs ===) koji će se koristiti u JavaScript usporedbi?

Koristim JSLint za prolazak kroz JavaScript i vraća puno rečenica koje zamjenjuju == (dva znaka jednakosti) s === (tri jednake oznake) kada učinite nešto poput usporedbe idSele_UNVEHtype.value.length == 0 operater if .

Postoji li prednost u izvedbi za zamjenu == to === ?

Svako poboljšanje izvedbe bit će dobrodošlo jer postoji mnogo operatora usporedbe.

Ako se konverzija tipa ne dogodi, hoće li se dobitak usporediti s == ?

5673
11 дек. postavila bcasp 11. prosinca 2008-12-11 17:19 '08 u 17:19 2008-12-11 17:19
ответ 51 odgovor
  • 1
  • 2

Operator identiteta ( === ) ponaša se jednako operatoru jednakosti ( == ), osim što se ne izvodi konverzija tipa, a tipovi moraju biti isti da bi se smatrali jednakima.

Reference: Javascript Tutorial: Operatori usporedbe

Operator == usporedit će za jednakost nakon obavljanja bilo koje potrebne konverzije tipa. Operator === neće izvršiti pretvorbu, tako da ako se dvije vrijednosti ne podudaraju, === jednostavno će se vratiti false . Oba su jednako brza.

Citat: Douglas Crockford odličan javascript: dobri dijelovi ,

U JavaScriptu postoje dva skupa operatora jednakosti: === i !== , a njihovi zli blizanci == i != . Dobri rade onako kako ste očekivali. Ako su dva operanda istog tipa i imaju istu vrijednost, tada === stvara true i !== proizvodi false . Zli blizanci čine pravu stvar kada su operandi istog tipa, ali ako imaju različite tipove, pokušavaju nametnuti vrijednosti. pravila koja oni čine složena su i nepremostiva. Evo nekoliko zanimljivih slučajeva:

 '' == '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 

Nedostatak tranzitivnosti je alarmantan. Moj savjet je da nikada ne koristite zle blizance. Umjesto toga uvijek koristite === i !== . Sve gore navedene usporedbe pokazuju false s operatorom === .


ažuriranje:

Dobra stvar je postavila @Casebash u komentarima iu @ Phillipe Laybaertu u vezi s referentnim tipovima. Za referentne vrste, == i === djeluju dosljedno (osim u posebnom slučaju).

 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 

Poseban slučaj je usporedba s literalom s objektom koji ocjenjuje isti literal zbog njegove toString ili valueOf . Na primjer, razmislite o uspoređivanju literalnog niza s nizom objekta koji je stvorio konstruktor String .

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

Ovdje operator == provjerava vrijednosti dvaju objekata i vraća true , ali === vidi da nisu istog tipa i vraćaju false . Koji je ispravan? To stvarno ovisi o tome što pokušavate usporediti. Moj savjet je da potpuno zaobiđete pitanje i jednostavno ne koristite String konstruktor za stvaranje nizova objekata.

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

5840
11 дек. Odgovor koji je dao Bill Lizard 11. prosinca 2008-12-11 17:25 '08 u 17:25 2008-12-11 17:25

Korištenje operatora == (jednakost)

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

Upotreba operatora === (Identitet)

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

To je zbog činjenice da operator jednakosti == ima tip prisile , što znači da interpreter implicitno pokušava pretvoriti vrijednosti prije usporedbe.

S druge strane, operator Identity === ne izvodi tip prisile i stoga ne konvertira vrijednosti kada uspoređuje.

1016
11 дек. Odgovor daje Andreas Grech 11 prosinca. 2008-12-11 17:33 '08 u 17:33 2008-12-11 17:33

U odgovorima ovdje nisam ništa pročitao o tome što znači jednako . Neki će reći da === znači jednako i istog tipa , ali nije. U stvari, to znači da se oba operanda odnose na isti objekt ili, u slučaju tipova vrijednosti , imaju istu vrijednost .

Uzmimo sljedeći kôd:

 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 

Isto ovdje:

 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 

Ili čak:

 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 

Takvo ponašanje nije uvijek očito. U priči ima više nego biti jednak i istog tipa.

pravilo:

Za vrste vrijednosti (brojeve):
a === b vraća true ako a i b imaju istu vrijednost i imaju isti tip

Za referentne vrste:
a === b vraća true ako se a i b odnose na isti objekt.

Za nizove:
a === b vraća true ako su a i b oba niza i sadrže iste znakove.


Žice: posebni slučaj ...

Nizovi nisu tipovi vrijednosti, ali u Javascriptu se ponašaju kao vrste vrijednosti, pa će biti "jednaki" kada su znakovi u nizu isti i kada su iste duljine (kao što je objašnjeno u trećem pravilu)

Sada postaje zanimljivo:

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

Ali što je s ovim?:

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

Mislio sam da se nizovi ponašaju kao vrste vrijednosti? Pa, to ovisi o tome koga pitate ... U ovom slučaju, a i b nisu iste vrste. a je tipa Object , a b je tipa string . Samo zapamtite da kreiranje objekta stringa pomoću konstruktora string stvara nešto poput tipa Object , koji se većinu vremena ponaša poput niza.

564
05 июня '09 в 22:11 2009-06-05 22:11 odgovorio je Philippeu Leybaertu na Lipanj 05 '09 u 10:11 2009-06-05 22:11

Zanimljiv grafički prikaz usporedbe jednakosti između == i === .

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


var1 === var2

Kada koristite === za testiranje JavaScript jednakosti, sve je kako jeste. Prije vrednovanja ništa se ne pretvara.

2019

553
05 мая '14 в 8:21 2014-05-05 08:21 odgovor je dao SNag 05. svibnja 2014. u 8:21 2014-05-05 08:21

Dopustite mi da dodam ovaj savjet:

Ako niste sigurni, pročitajte specifikaciju !

ECMA-262 je specifikacija skript jezika u kojoj je JavaScript dijalekt. Naravno, u praksi je važno kako se ponašaju najvažniji preglednici, a ne ezoterična definicija kako se nešto treba rješavati. Ali korisno je razumjeti zašto novi String ("a")! == "a" .

Dopustite mi da objasnim kako pročitati specifikaciju da pojasnim ovaj problem. Vidim da u ovoj vrlo staroj temi nitko nije dobio odgovor za vrlo čudan učinak. Dakle, ako možete pročitati specifikacije, to će vam puno pomoći u vašoj profesiji. Ovo je stečena vještina. Dakle, samo naprijed.

Pronalaženje PDF datoteke za === vodi me na stranicu 56 specifikacije: 11.9.4. Operator Strict Equals (===) i nakon prolaska kroz specifikaciju nalazim:

11.9.6 Algoritam za usporedbu strogih jednakosti
Usporedba x === y, gdje su x i y vrijednosti, stvara true ili false . Takva se usporedba izvodi na sljedeći način:
1. Ako se Tip (x) razlikuje od Tipa (y), vratite false .
2. Ako je tip (x) nedefiniran, vratite true .
3. Ako je tip (x) Null, vratite true .
4. Ako tip (x) nije broj, prijeđite na 11. korak.
5. Ako je x NaN , vratite false .
6. Ako je y NaN , vratite false .
7. Ako je x ista brojčana vrijednost kao y, vratite true .
8. Ako je x +0 i y je -0, vratite istinu .
9. Ako je x -0 i y je +0, vratite istinu .
10. Vrati lažno .
11. Ako je Tip (x) String, vratite true ako su x i y točno isti niz znakova (iste duljine i istih znakova u odgovarajućim položajima); u suprotnom, vratite false .
12. Ako je tip (x) boolean, vratite true ako su x i y istiniti ili oboje lažno ; u suprotnom, vratite false .
13. Vratite true ako x i y pripadaju istom objektu ili se odnose na objekte koji su međusobno povezani (vidi 13.1.2). U suprotnom, vratite false .

Zanimljiva je faza 11. Da, nizovi se tretiraju kao tipovi vrijednosti. Ali to ne objašnjava zašto novi String ("a")! == "a" . Imamo li ne-ECMA-262 preglednik?

Ne tako brzo!

Provjerite vrste operanda. Pokušajte sami tako da ih omotate u typeof () . Otkrio sam da je novi String ("a") objekt, a koristi se korak 1: vrati false ako su tipovi različiti.

Ako se pitate zašto novi String ("a") ne vraća niz, kako o nekim vježbama koje su pročitale specifikaciju? Zabavite se!


Aidiakapi je ovo napisao u komentaru ispod:

Iz specifikacije

11.2.2 Novi operator :

Ako tip (konstruktor) nije objekt, podignite izuzetak TypeError.

Drugim riječima, ako niz nije tipa Object, ne može se koristiti s novim operatorom.

new uvijek vraća objekt, čak i za konstruktore stringova . I nažalost! Semantika vrijednosti za nizove (vidi korak 11) je izgubljena.

I to konačno znači: novi String ("a")! == "a" .

254
28 нояб. Odgovor je danly 28 nov. 2009-11-28 21:18 '09 u 21:18 2009-11-28 21:18

U PHP-u i JavaScriptu, ovo je strogi operator jednakosti. To znači da će usporediti vrstu i vrijednosti.

95
12 мая '10 в 15:58 2010-05-12 15:58 odgovor je dao Shiki 12. svibnja '10 u 15:58 2010-05-12 15:58

Testirao sam ga u Firefoxu koristeći Firebug pomoću sljedećeg koda:

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

i

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

Moji rezultati (označeno pet puta i prosječno):

 ==: 115.2 ===: 114.4 

Dakle, rekao bih da je mala razlika (to je više od 100.000 iteracija, zapamtite) zanemariva. Izvedba nije uzrok === . Vrsta sigurnosti (dobro, sigurno kao što će biti javascript) i kvaliteta koda.

91
25 дек. Odgovor daje Simon Scarfe 25. prosinca. 2008-12-25 14:17 '08 u 14:17 2008-12-25 14:17

U JavaScriptu to znači istu vrijednost i vrstu.

Na primjer

 4 == "4" // will return true 

ali

 4 === "4" // will return false 
88
12 мая '10 в 15:58 2010-05-12 15:58 odgovor je dao Dimitar 12. svibnja '10. u 15:58 2010-05-12 15:58

Operator === naziva se operator stroge usporedbe, on se razlikuje od operatora == .

Uzmite 2 vara a i b.

Za "a == b" za procjenu istine a i b treba biti jedna vrijednost .

U slučaju "a === b" a i b moraju biti iste vrijednosti , kao i isti tip da bi se procijenila istina.

Uzmite sljedeći primjer

 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"); } 

U zaključku ; Korištenje == operatora može biti ocijenjeno kao istinito u situacijama u kojima ga ne želite, pa će upotreba === operatora biti sigurnija.

U scenariju upotrebe od 90% nije bitno koji se koristi, ali je korisno znati razliku kada jednog dana dobijete neočekivano ponašanje.

77
11 дек. Odgovor daje doktor Jones 11. prosinca 2008-12-11 17:58 '08 u 17:58 2008-12-11 17:58

Provjerava jesu li iste strane jednake vrste i vrijednosti .

primjer:

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

Opći primjer:

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

Drugi uobičajeni primjer je:

 null == undefined // returns "true", but in most cases a distinction is necessary 
70
12 мая '10 в 15:58 2010-05-12 15:58 odgovor je dao vsync 12. svibnja '10 u 15:58 2010-05-12 15:58

Zašto je to tako nepredvidljivo?

Što dobivate kada usporedite prazan niz "" s brojem 0 0 ?

<code> Truecode>

Da, to je točno u skladu s == praznim nizom, a numerička nula je isto vrijeme.

I to se ovdje ne završava, drugo:

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

Stvari postaju vrlo čudne s nizovima.

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

Zatim slijedi žice

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

Pogoršanje:

Kada nije jednako?

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

Dopustite mi da još jednom kažem:

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

A ovo su samo lude stvari koje dobivate s primitivcima.

Ovo je nova razina ludila kada koristite == s objektima.

Sada se vjerojatno pitate ...

Zašto se to događa?

Dobro, jer za razliku od "trostruke jednakosti" ( === ), koja jednostavno provjerava odgovaraju li dvije vrijednosti.

== cijelu gomilu drugih stvari .

Ona ima posebnu obradu za funkcije, posebnu obradu za nule, nedefinirane, nizove, koje zovete.

Postaje prilično glupo.

Zapravo, ako pokušate napisati funkciju koja radi ono što radi == , izgledat će ovako:

  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(); } Код> 

Što to znači?

To znači da je == složen.

Budući da je teško, teško je shvatiti što će se dogoditi kada ga koristite.

To znači da možda imate pogreške.

Dakle, moral priče ...

Učinite svoj život manje kompliciranim.

Upotrijebite === umjesto == .

Kraj.

68
09 авг. odgovor je dao Luis Perez 09 aug. 2016-08-09 19:50 '16 u 19:50 2016-08-09 19:50

Dijagram sekvence izvođenja Javascripta za strogu jednakost / Usporedba '==='

2019

05 сент. odgovor je dan Samar Panda 05 sep. 2015-09-05 16:53 '15 u 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 odgovor je dao korisnik2496033 3. srpnja '13. u 7:08 2013-07-03 07:08

To znači jednakost bez prisile tipa, a tip prisile znači da JavaScript ne pretvara automatski bilo koji drugi tip podataka u tipove podataka niza.

 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 odgovor je dao Pop Catalin 12. svibnja '10 u 15:59 2010-05-12 15:59

U tipičnom skripti neće biti razlike u izvedbi. Što je još važnije, činjenica da je tisuću "===" 1 kilobajt teža od tisuću "==" :) JavaScript profileri mogu vam reći ako postoji razlika u izvedbi u vašem slučaju.

Ali osobno bih učinio ono što JSLint nudi. Ova preporuka nije zbog problema s performansama, nego zbog ograničenja vrste ('\t\r\n' == 0) .

46
16 дек. odgovor dao Konstantin 16 dec. 2008-12-16 17:29 '08 u 17:29 2008-12-16 17:29

Jednaki operator za usporedbu == je zbunjen i treba ga izbjegavati.

Ako živite s HAVE , zapamtite sljedeće 3 stvari:

  • Nije tranzitivna: (a == b) i (b == c) ne rezultira (a == c)
  • On međusobno isključuje njegovu negaciju: (a == b) i (a! = B) uvijek imaju suprotne logičke vrijednosti sa svim a i b.
  • Kada sumnjate, zapamtite sljedeću tablicu istine:

TABLICA PRAVOG OPERATORA U JAVASCRIPTU

  • Svaki redak tablice je skup od 3 međusobno "jednake" vrijednosti, što znači da je svaka od njih 2 jednaka korištenjem znaka jednakosti == *

** STRANGE: imajte na umu da bilo koje dvije vrijednosti u prvom stupcu nisu jednake u tom smislu. **

 '' == 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 сент. odgovor od CuongHuyTo 16. rujna 2011-09-16 17:25 '11 u 17:25 2011-09-16 17:25

Jedva da postoji razlika u izvedbi između dvije operacije u vašem korištenju. Nema izvedbe konverzije tipa, jer su oba parametra istog tipa. Obje operacije imat će usporedbu vrsta nakon koje slijedi usporedba vrijednosti.

35
11 дек. odgovor dan Sean 11. \ t 2008-12-11 17:44 '08 u 17:44 2008-12-11 17:44

Da! Važno je.

=== u javascriptu provjerava vrijednost, kao i tip , gdje operator == jednostavno provjerava vrijednost (pretvara tip ako je potrebno) .

2019

35
14 нояб. Odgovor koji je dao Aniket Thakur 14. studenog 2014-11-14 09:02 '14 u 9:02 2014-11-14 09:02
operater

=== provjerava vrijednosti kao i vrste varijabli za jednakost.

operater

== samo provjerava vrijednost varijabli za jednakost.

32
12 мая '10 в 16:03 2010-05-12 16:03 odgovor je dao Niraj Choubey 12. svibnja 2010. u 16:03 2010-05-12 16:03

Ovo je strogi test.

Ovo je dobro, pogotovo ako provjerite između 0 i false i null.

Na primjer, ako imate:

 $a = 0; 

zatim:

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

Sve se vraća istini i možda je ne želite. Pretpostavimo da imate funkciju koja može vratiti indeks indeksa 0 ili pogrešku na pogrešku. Ako označite okvir s "==" false, možete dobiti zbunjujući rezultat.

Dakle, s istim gore navedenim, ali strogim testom:

 $a = 0; $a===0; // returns true $a===NULL; // returns false $a===false; // returns false 
30
12 мая '10 в 16:19 2010-05-12 16:19 Odgovor je dan Daniel 12. svibnja '10. U 16:19. 2010-05-12 16:19

JSLint ponekad daje nerealne razloge za promjenu materijala. === ima istu izvedbu kao == ako se vrste već podudaraju.

Ovo je brže samo ako se vrste ne podudaraju, u tom slučaju ne pokušava pretvoriti vrste, ali vraća false.

Dakle, IMHO, JSLint se može koristiti za pisanje novog koda, ali beskorisnu pretjeranu optimizaciju treba izbjegavati pod svaku cijenu.

Znači, nema razloga za promjenu == u === u testu, na primjer if (a == 'test') , kada to znate, jer činjenica može biti samo niz.

Mijenjanje velike količine koda na ovaj način zahtijeva vrijeme programera i recenzenata i ne postiže ništa.

29
05 июня '12 в 10:53 2012-06-05 10:53 odgovor dan ashes dana lipnja 05 '12 u 10:53 2012-06-05 10:53

samo

== znači usporedbu između operanda s type conversion

=== znači usporedbu između operanada bez type conversion

Pretvorba tipa u javaScript znači da javaScript automatski pretvara bilo koje druge vrste podataka u tipove podatkovnih nizova.

Na primjer:

 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
20 марта '15 в 8:05 2015-03-20 08:05 odgovor je dat Amit 20. ožujka '15 u 8:05 2015-03-20 08:05

Jednostavan primjer je

 2 == '2' -> true, values are SAME because of type conversion. 2 === '2' -> false, values are NOT SAME because of no type conversion. 
25
14 мая '15 в 17:45 2015-05-14 17:45 odgovor daje Vikas 14. svibnja '15. u 17:45 sati 2015-05-14 17:45