Kuris operatorius yra lygus (== vs ===), naudojamas „JavaScript“ palyginime?

Aš naudoju JSLint, kad pereitume JavaScript, ir grąžina daugelį sakinių, pakeičiančių == (du vienodus ženklus) su === (trys lygūs ženklai), kai darote kažką panašaus į palyginimą idSele_UNVEHtype.value.length == 0 viduje operatorius, if .

Ar yra efektyvumo pranašumas pakeičiant == į === ?

Bet kokie efektyvumo pagerinimai bus sveikintini, nes yra daug palyginimo operatorių.

Jei tipo konvertavimas neįvyks, ar gautas pelnas bus lyginamas su == ?

5673
11 дек. nustatė bcasp gruodžio 11 2008-12-11 17:19 '08, 17:19, 2008-12-11 17:19
ответ 51 atsakymas
  • 1
  • 2

Identifikacijos operatorius ( === ) elgiasi vienodai su lygybės operatoriumi ( == ), išskyrus tai, kad tipo konvertavimas nėra atliekamas, o tipai turi būti tokie patys, kaip ir lygūs.

Nuoroda: „ Javascript“ pamoka: palyginimo operatoriai

== operatorius == lygiateisiškumą po bet kokių būtinų tipų konversijų. Operatorius === konversijos, taigi, jei dvi vertės nesutampa, tada === paprasčiausiai grąžins klaidą. Abi yra vienodai greitai.

Citata Douglas Crockford puikus javascript: geros dalys ,

„JavaScript“ sistemoje yra du lygybės operatorių rinkiniai: === ir !== , ir jų blogi dvyniai == ir != . Gerieji dirba taip, kaip tikėjotės. Jei du tos pačios rūšies operandai turi tą pačią vertę, tada === sukuria true ir !== gamina false . Blogi dvyniai daro teisingą dalyką, kai operandai yra to paties tipo, tačiau jei jie turi skirtingus tipus, jie stengiasi įgyvendinti vertybes. taisyklės, pagal kurias jos yra sudėtingos ir neįveikiamos. Štai keletas įdomių atvejų:

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

Tranzito trūkumas kelia nerimą. Mano patarimas niekada nenaudoti blogų dvynių. Vietoj to, visada naudokite === ir !== . Visi aukščiau pateikti palyginimai rodo, kad operatorius yra false === .


Atnaujinti:

Geras taškas buvo iškeltas @Casebash pastabose ir @Pillii Laybaert apie referencinius tipus. Nuorodų tipams == ir === veikti vieni su kitais (išskyrus ypatingą atvejį).

 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 

Ypatingas atvejis yra pažodinio palyginimas su objektu, kuris vertina tą pačią gramatinę valueOf toString arba „ valueOf . Pavyzdžiui, apsvarstykite galimybę lyginti eilutę su eilutės objektu, kurį sukūrė String konstruktorius.

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

Čia == operatorius tikrina dviejų objektų vertes ir grąžina true , bet === mato, kad jie nėra tokio paties tipo ir grįžta false . Kuris iš jų yra teisingas? Tai tikrai priklauso nuo to, ką bandote palyginti. Mano patarimas yra visiškai apeiti klausimą ir tiesiog nesinaudoti String konstruktoriumi styginių objektų kūrimui.

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

5840
11 дек. Bill the Lizard atsakymas, pateiktas gruodžio 11 d 2008-12-11 17:25 '08 at 17:25 pm 2008-12-11 17:25

Naudotojo == operatoriaus (lygybės) naudojimas

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

Operatoriaus naudojimas === (tapatybė)

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

Taip yra dėl to, kad lygybės operatorius == turi prievartos tipą , o tai reiškia, kad vertėjas netiesiogiai bando konvertuoti vertes prieš palyginimą.

Kita vertus, „ Identity === operatorius neatlieka prievartos tipo , todėl, lygindamas vertes, nekonvertuoja.

1016
11 дек. Atsakymą pateikė Andreas Grech 11 d. 2008-12-11 17:33 '08, 17:33 2008-12-11 17:33

Atsakymuose čia neskaityiau nieko apie tai, kas yra lygi . Kai kurie pasakys, kad === reiškia vienodą ir tos pačios rūšies , bet ne. Tiesą sakant, tai reiškia, kad abu operandai nurodo tą patį objektą , o vertės tipų atveju - tą pačią vertę .

Taigi, atlikite šį kodą:

 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 

Tas pats čia:

 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 

Arba net:

 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 

Šis elgesys ne visada akivaizdus. Yra daugiau istorijos, nei lygiavertės ir tos pačios rūšies.

Taisyklė:

Vertės tipams (skaičiams):
a === b grįžta tiesa, jei a ir b turi tą pačią vertę ir turi tą patį tipą

Nuorodų tipams:
a === b grįžta tiesa, jei a ir b nurodo tą patį objektą.

Styginiams:
a === b grįžta tiesa, jei a ir b yra abu stygos ir jame yra tie patys simboliai.


Stygos: specialus atvejis ...

Stygos nėra vertybių rūšys, tačiau „Javascript“ sistemoje jie veikia kaip vertės tipai, todėl jie bus „lygūs“, kai eilutės simboliai yra vienodi ir kai jie yra tokie patys (kaip paaiškinta trečioje taisyklėje)

Dabar tampa įdomu:

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

Bet kaip apie tai?

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

Maniau, kad stygos elgiasi kaip vertės rūšys? Na, tai priklauso nuo to, kas prašote ... Šiuo atveju a ir b nėra to paties tipo. a yra tipo Object , o b yra tipo string . Atminkite, kad styginių objekto kūrimas naudojant string konstruktorių sukuria kažką panašaus į Object , kuris dažniausiai elgiasi kaip eilutė.

564
05 июня '09 в 22:11 2009-06-05 22:11 atsakė Philippe Leybaert 05 05 val. 10:11 2009-06-05 22:11

Įdomus lyginamojo == ir === palyginimo grafinis vaizdas.

Šaltinis: http://dorey.github.io/JavaScript-Equality-Table/


var1 === var2

Naudojant === kad išbandytumėte „JavaScript“ lygybę, viskas yra taip. Niekas nekeičiamas prieš vertinimą.

2019

553
05 мая '14 в 8:21 2014-05-05 08:21 atsakymą pateikė SNag 05 gegužės 14 d. 8:21 2014-05-05 08:21

Leiskite pridėti šį patarimą:

Jei abejojate, perskaitykite specifikaciją !

ECMA-262 yra scenarijų kalbos specifikacija, kurioje „JavaScript“ yra tarmė. Žinoma, praktiškai svarbu, kaip elgiasi svarbiausios naršyklės, o ne esoterinis apibrėžimas, kaip kažką reikia tvarkyti. Tačiau naudinga suprasti, kodėl nauja eilutė („a“)! == "a" .

Leiskite paaiškinti, kaip skaityti specifikaciją, kad išsiaiškintumėte šią problemą. Matau, kad šioje labai senoje temoje niekas negavo atsakymo į labai keistą efektą. Taigi, jei galite perskaityti specifikaciją, tai padės jums daug savo profesijos. Tai įgytas įgūdis. Taigi eikite į priekį.

PDF failo paieška === veda prie specifikacijos 56 puslapio: 11.9.4. Operatorius „Strict Equals“ (===) ir, atlikęs specifikaciją, radau:

11.9.6 Griežto lygybės palyginimo algoritmas
Lyginant x === y, kur x ir y yra reikšmės, sukuriama teisinga arba klaidinga . Toks palyginimas atliekamas taip:
1. Jei tipas (x) skiriasi nuo tipo (y), grąžinkite klaidingą .
2. Jei tipas (x) yra neapibrėžtas, grąžinkite teisingą .
3. Jei tipas (x) yra Null, grįžkite tiesa .
4. Jei tipas (x) nėra skaičius, pereikite prie 11 veiksmo.
5. Jei x yra NaN , grąžinkite klaidingą .
6. Jei y yra NaN , grąžinkite klaidingą .
7. Jei x yra ta pati skaitinė vertė, kaip y, sugrįžkite teisingai .
8. Jei x yra +0 ir y yra -0, grįžkite tiesa .
9. Jei x yra -0 ir y yra +0, grįžkite tiesa .
10. Grąžinti klaidingą .
11. Jei tipas (x) yra eilutė, grąžinkite tiesa, jei x ir y yra lygiai tokia pati simbolių seka (tas pats ilgis ir tie patys simboliai atitinkamose pozicijose); kitaip grąžinkite klaidingą .
12. Jei tipas (x) yra loginis, grąžinkite tiesa, jei x ir y abu yra teisingi arba abu false ; kitaip grąžinkite klaidingą .
13. Grįžti tiesa, jei x ir y priklauso tam pačiam objektui arba yra susiję su viena su kitu susijusiais objektais (žr. 13.1.2). Priešingu atveju grąžinkite klaidingą .

11 etapas yra įdomus Taip, stygos vertinamos kaip vertės rūšys. Tačiau tai nepaaiškina, kodėl nauja eilutė („a“)! == "a" . Ar turime ne ECMA-262 naršyklę?

Ne taip greitai!

Patikrinkite operandų tipus. Išbandykite save, apvynioję juos į tipo () . Radau, kad naujasis eilutė ("a") yra objektas, o 1 - as žingsnis: grąžinti klaidingą, jei tipai yra skirtingi.

Jei įdomu, kodėl nauja eilutė („a“) negrąžina eilutės, kaip apie kai kuriuos pratimus, skaitančius specifikaciją? Smagiai!


Aidiakapi parašė šį komentarą toliau:

Iš specifikacijos

11.2.2 Naujas operatorius :

Jei tipas (konstruktorius) nėra objektas, išimkite TypeError išimtį.

Kitaip tariant, jei eilutė nėra objekto tipo, ji negali būti naudojama su nauju operatoriumi.

naujas visada grąžina objektą, net ir styginių konstruktoriams. Ir deja! Styginių reikšmės semantika (žr. 11 žingsnį) prarandama.

Ir tai galiausiai reiškia: naują eilutę ("a")! == "a" .

254
28 нояб. Atsakymas pateikiamas 28 d. 2009-11-28 21:18 '09 21:18 2009-11-28 21:18

PHP ir JavaScript tai yra griežtas lygybės operatorius. Tai reiškia, kad jis palygins tipą ir vertes.

95
12 мая '10 в 15:58 2010-05-12 15:58 atsakymą pateikė „ Shiki “ gegužės 12 d., 10 val. 15:58 2010-05-12 15:58

Bandau jį „Firefox“ naudodamas „ Firebug“ naudodamas šį kodą:

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

ir

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

Mano rezultatai (patikrinti penkis kartus ir vidurkis):

 ==: 115.2 ===: 114.4 

Taigi, sakyčiau, kad nedidelis skirtumas (tai daugiau nei 100 000 iteracijų, nepamirškite) yra nereikšmingas. Veikimas nėra priežastis === . Saugumo tipas (gerai, saugus, kaip jūs ketinate „javascript“), ir kodo kokybė.

91
25 дек. Atsakymą davė Simon Scarfe gruodžio 25 d. 2008-12-25 14:17 '08 at 2:17 pm 2008-12-25 14:17

„JavaScript“ tai reiškia tą pačią vertę ir tipą.

Pavyzdžiui

 4 == "4" // will return true 

bet

 4 === "4" // will return false 
88
12 мая '10 в 15:58 2010-05-12 15:58 atsakymą davė Dimitar , gegužės 12 d., 10 val. 15:58 2010-05-12 15:58

=== operatorius vadinamas griežtu palyginimo operatoriumi, jis skiriasi nuo == operatoriaus.

Paimkite 2 vars a ir b.

„A == b“, norint įvertinti a ir b tiesą, turėtų būti viena reikšmė .

"A === b" atveju a ir b turi būti tos pačios vertės , kaip ir tos pačios rūšies , kad galėtų įvertinti tiesą.

Paimkite šį pavyzdį

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

Apibendrinant ; Operatoriaus == naudojimas gali būti vertinamas kaip teisingas tokiose situacijose, kai to nenorite, todėl naudodami === operatorių bus saugesnis.

90% naudojimo scenarijuje nesvarbu, kuris iš jų naudojamas, bet naudinga žinoti skirtumą, kai vieną dieną gaunate netikėtą elgesį.

77
11 дек. Atsakymą pateikė daktaras Jonesas gruodžio 11 d. 2008-12-11 17:58 '08 at 17:58 pm 2008-12-11 17:58

Ji patikrina, ar tos pačios pusės yra vienodos rūšies ir vertės .

Pavyzdys:

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

Bendras pavyzdys:

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

Kitas bendras pavyzdys:

 null == undefined // returns "true", but in most cases a distinction is necessary 
70
12 мая '10 в 15:58 2010-05-12 15:58 atsakymą pateikė vsync gegužės 12 d. 10 val. 15:58 2010-05-12 15:58

Kodėl == taip nenuspėjamas?

Ką gausite lyginant tuščią eilutę su numeriu 0 0 ?

<code> Truecode>

Taip, tai teisinga pagal == tuščią eilutę, o skaitinis nulis yra vienodas.

Ir tai nesibaigia čia, dar vienas:

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

Daiktai gauna labai keistą matricą.

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

Tada pasukite su stygomis

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

Blogiau:

Kada nėra lygus?

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

Leiskite dar kartą pasakyti:

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

Ir tai yra tik beprotiška medžiaga, kurią gaunate su primityviais.

Tai yra naujas beprotybės lygis, kai naudojate == su objektais.

Šiuo metu jums tikriausiai įdomu ...

Kodėl taip vyksta?

Gerai, nes skirtingai nuo „trigubos lygybės“ ( === ), kuri tiesiog tikrina, ar dvi vertės atitinka.

== daroma visa kita krūva .

Jis turi specialų apdorojimą funkcijoms, specialų nulio apdorojimą, neapibrėžtas, eilutes, kurias skambinate.

Jis tampa gana kvailas.

Iš tiesų, jei bandėte parašyti funkciją, kuri daro tai, ką daro == , tai atrodys taip:

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

Taigi, ką tai reiškia?

Tai reiškia, kad == yra sudėtingas.

Kadangi sunku, sunku suprasti, kas nutiks, kai ją naudosite.

Tai reiškia, kad gali būti klaidų.

Taigi pasakojimo moralė ...

Padarykite savo gyvenimą mažiau sudėtingą.

Naudokite === vietoj == .

Galas.

68
09 авг. atsakymą pateikė Luis Perez 09 rug. 2016-08-09 19:50 '16 at 7:50 pm 2016-08-09 19:50

„JavaScript“ vykdymo sekos schema, skirta griežtai lygybei / palyginimas „===“

2019

05 сент. atsakymas pateikiamas Samar Panda 05 sep. 2015-09-05 16:53 '15 at 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 atsakymą pateikė vartotojo2496033 liepos 03 '13, 07:08 2013-07-03 07:08

Tai reiškia lygybę be tipo prievartos, o prievartos tipas reiškia, kad „JavaScript“ automatiškai nekeičia jokių kitų duomenų tipų į styginių duomenų tipus.

 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 atsakymą pateikė „ Pop Catalin “ gegužės 10 d., 10 val. 15:59 2010-05-12 15:59

Įprastame scenarijuje nebus skirtumų. Dar svarbiau yra tai, kad tūkstantis "===" yra 1 kilobyte yra sunkesnis už tūkstantį "==" :) JavaScript profiliai gali jums pasakyti, ar jūsų atveju yra skirtumų.

Bet asmeniškai norėčiau daryti tai, ką siūlo JSLint. Ši rekomendacija nėra susijusi su našumo problemomis, bet dėl ​​tipo apribojimo ('\t\r\n' == 0) .

46
16 дек. atsakymas suteiktas Konstantinui 16 d. 2008-12-16 17:29 '08 at 17:29 pm 2008-12-16 17:29

„Equal“ palyginimo operatorius == yra painus ir turėtų būti vengiamas.

Jei gyvenate su HAVE , prisiminkite šiuos 3 dalykus:

  • Jis nėra transityvus: (a == b) ir (b == c) nesukelia (a == c)
  • Ji tarpusavyje pašalina jos neigimą: (a == b) ir (a! = B) visada turi priešingas Būlio reikšmes su visais a ir b.
  • Jei abejojate, prisiminkite šią tiesos lentelę:

TEISINIO OPERATORIAUS LENTELĖ JAVASCRIPT

  • Kiekviena lentelės eilutė yra 3 tarpusavyje „lygių“ reikšmių rinkinys, o tai reiškia, kad bet kurios 2 jų vertės yra lygios, naudojant lygų == * ženklą

** STRUKTŪRA: Atkreipkite dėmesį, kad bet kurios dvi vertės pirmoje stulpelyje nėra vienodos. **

 '' == 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 сент. CuongHuyTo atsakymas, pateiktas rugsėjo 16 d 2011-09-16 17:25 '11, 17:25, 2011-09-16 17:25

Nėra beveik jokių skirtumų tarp dviejų jūsų naudojamų operacijų. Nėra jokio tipo konvertavimo, nes abu parametrai yra to paties tipo. Abi operacijos turės tipo palyginimą, po kurio bus lyginamas vertės palyginimas.

35
11 дек. atsakymas duotas Sean 11 Dec 2008-12-11 17:44 '08, 17:44 2008-12-11 17:44

Taip Tai svarbu.

=== „Javascript“ operatorius tikrina vertę, taip pat tipą , kur operatorius == tiesiog tikrina vertę (jei reikia, konvertuoja tipą) .

2019

35
14 нояб. Aniket Thakur atsakymas lapkričio 14 d 2014-11-14 09:02 '14 at 9:02 2014-11-14 09:02
Operatorius

=== tikrina lygias vertybes ir kintamųjų tipus.

Operatorius

== tiesiog tikrina kintamųjų reikšmę lygybei.

32
12 мая '10 в 16:03 2010-05-12 16:03 atsakymą pateikė Niraj Choubey gegužės 10 d., 10 val

Tai yra griežtas testas.

Tai gera, ypač jei patikrinate tarp 0 ir netikrų ir nulinių.

Pavyzdžiui, jei turite:

 $a = 0; 

Tada:

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

Viskas grįžta tiesa ir jūs to nenorite. Tarkime, kad turite funkciją, kuri gali grąžinti 0 masyvo indeksą arba klaidą klaidoje. Jei pažymėsite >

Taigi, kaip ir anksčiau, bet griežtas testas:

 $a = 0; $a===0; // returns true $a===NULL; // returns false $a===false; // returns false 
30
12 мая '10 в 16:19 2010-05-12 16:19 Atsakymas duotas Danieliui gegužės 10 d. 10, 16:19 2010-05-12 16:19

JSLint kartais suteikia nerealių priežasčių keisti medžiagą. === turi tą patį našumą kaip == jei tipai jau atitinka.

Tai greitesnė tik tuo atveju, jei tipai nesutampa, tokiu atveju jis nesistengia konvertuoti tipų, bet grąžina klaidingą.

Taigi, IMHO, JSLint gali būti naudojamas naujam kodui parašyti, tačiau nereikalinga per daug optimizacija turėtų būti vengiama bet kokia kaina.

Tai reiškia, kad nėra jokios priežasties keisti == iki === teste, pavyzdžiui, if (a == 'test') , kai jį žinote, nes faktas gali būti tik eilutė.

Tokiu būdu modifikuojant didelį kodo kiekį, reikia laiko kūrėjams ir recenzentams ir nieko nepasiekia.

29
05 июня '12 в 10:53 2012-06-05 10:53 atsakymas pelenams buvo pateiktas birželio 12 d. 12 val

Tiesiog

== reiškia operandų palyginimą su type conversion

=== reiškia operandų be type conversion palyginimą

Tipo konvertavimas javaScript reiškia, kad javaScript automatiškai konvertuoja bet kuriuos kitus duomenų tipus į eilutės duomenų tipus.

Pavyzdžiui:

 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 atsakymas pateikiamas Amit 20 d., 15 val. 8:05 2015-03-20 08:05

Paprastas pavyzdys yra

 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 atsakymą pateikė Vikas gegužės 15 d. 15 val. 17:45 2015-05-14 17:45

Top 2 atsakymai abiem minėtiems == reiškia lygybę ir === reiškia identifikatorių. Deja, šis teiginys neteisingas.