Aling mga operator ay pantay (== vs ===) upang magamit sa paghahambing ng JavaScript?

Ginagamit ko ang JSLint upang pumunta sa pamamagitan ng JavaScript, at nagbabalik ito ng maraming mga pangungusap upang palitan ang == (dalawang magkatulad na tanda) na may === (tatlong pantay na palatandaan) kapag ginawa mo ang isang bagay tulad ng paghahambing idSele_UNVEHtype.value.length == 0 loob operator if .

Mayroon bang pagganap ng kalamangan para sa pagpapalit == sa === ?

Anumang pagpapahusay ng pagganap ay malugod na tatanggapin ng maraming mga operator ng paghahambing.

Kung ang uri ng conversion ay hindi mangyayari, ay ang kumpara sa == ?

5673
11 дек. itinakda ng bcasp Disyembre 11 2008-12-11 17:19 '08 sa 17:19 2008-12-11 17:19
ответ 51 mga sagot
  • 1
  • 2

Ang operator ng pagkakakilanlan ( === ) ay kumikilos nang magkatulad sa operator ng pagkakapantay-pantay ( == ), maliban na ang uri ng conversion ay hindi gumanap, at ang mga uri ay dapat na pareho upang maituring na pantay.

Sanggunian: Javascript Tutorial: Paghahambing ng mga Operator

Ang == operator ay ihahambing para sa pagkakapantay-pantay pagkatapos gumaganap ng anumang kinakai>=== ay hindi gagawa ng conversion, kaya kung ang dalawang mga halaga ay hindi tumutugma, pagkatapos === ay babalik lamang ang false . Pareho si>

Quote Douglas Crockford mahusay na javascript: magandang bahagi ,

Sa JavaScript, mayroong dalawang hanay ng mga operator ng pagkakapantay-pantay: === at !== , at ang kani>== at != . Ang mga mabubuti ay gumagawa ng paraan na iyong inaasahan. Kung ang dalawang operands ng parehong uri ay may parehong halaga, pagkatapos === lumilikha ng true at !== gumagawa ng false . Ang masasamang kambal ay gumagawa ng tamang bagay kapag ang mga operasyon ay may parehong uri, ngunit kung mayroon si>

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

Ang kaku>=== at !== . Ang lahat ng mga paghahambing sa itaas ay nagpapakita ng false sa operator === .


I-update:

Ang isang magandang punto ay itinaas ng @ Casebash sa mga komento at sa @Phillipe Laybaert tungkol sa mga uri ng sanggunian. Para sa mga uri ng sanggunian, == at === kumilos nang tuloy-tuloy sa bawat isa (maliban sa espesyal na kaso).

 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 

Ang isang espesyal na kaso ay ang paghahambing ng isang literal na may isang bagay na sinusuri ang parehong literal dahil sa kanyang toString o valueOf . Halimbawa, isaa>String ng String .

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

Dito, sinusuri ng == operator ang mga halaga ng dalawang bagay at nagbabalik true , ngunit === nakikita na hindi sila pareho ng uri at nagbabalik false . Alin ang tama? Ito ay talagang depende sa kung ano ang sinusubukan mong ihambing. Ang aking payo ay upang ganap na iwasan ang tanong at hindi lamang gamitin ang String tagapagbuo upang lumikha ng mga bagay na string.

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

5840
11 дек. Sumagot na ibinigay ni Bill the Lizard noong Disyembre 11 2008-12-11 17:25 '08 at 5:25 pm 2008-12-11 17:25

Gamit ang == operator (pagkakapantay)

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

Gamit ang operator === (Identity)

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

Ito ay dahil sa ang katunayan na ang operator ng pagkakapantay - pantay == ay may uri ng pamimilit , na nangangahulugang ang tagasalin ay nagpapahiwatig na i-convert ang mga halaga bago ang paghahambing.

Sa kabi>Identity === operator ay hindi nagsasagawa ng uri ng pamimilit at, samakatuwid, ay hindi nagko-convert ng mga halaga kapag inihambing.

1016
11 дек. Ang sagot ay ibinigay sa pamamagitan ng Andreas Grech 11 dec. 2008-12-11 17:33 '08 sa 17:33 2008-12-11 17:33

Sa mga sagot dito, wala akong nabasa kahit ano tungkol sa kung ano ang pantay na paraan. Ang ilan ay sasabihin na === nangangahulugang katumbas at ng parehong uri , ngunit hindi. Sa katunayan, ito ay nangangahulugan na ang parehong mga operasyon ay tumutukoy sa parehong bagay o, sa kaso ng mga uri ng halaga , ay may parehong halaga .

Kaya gawin natin ang sumusunod na code:

 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 

Parehong narito:

 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 

O kahit na:

 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 

Ang pag-uugali na ito ay hindi laging halata. Mayroong higit pa sa kuwento kaysa sa pagiging pantay at sa parehong uri.

Panuntunan:

Para sa mga uri ng halaga (mga numero):
a === b bumalik nang totoo kung ang a at b may parehong halaga at may parehong uri

Para sa mga uri ng sanggunian:
a === b bumalik nang totoo kung ang a at b tumutukoy sa parehong bagay.

Para sa mga string:
a === b nagbabalik totoo kung ang a at b ay parehong mga string at naglalaman ng parehong mga character.


Mga string: espesyal na kaso ...

Ang mga string ay hindi mga uri ng halaga, ngunit sa Javascript kumilos sila tulad ng mga uri ng halaga, kaya sila ay magiging "pantay" kapag ang mga character sa string ay pareho at kapag sila ay parehong haba (tulad ng ipinaliwanag sa ikatlong panuntunan)

Ngayon nagiging kawili-wili ito:

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

Ngunit paano ang tungkol dito?:

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

Naisip ko na ang mga string ay kumikilos tulad ng mga uri ng halaga? Buweno, depende ito sa kung sino ang hinihiling mo ... Sa kasong ito, ang a at b ay hindi ang parehong uri. a uri ng Object , at b ay isang uri ng string . Tandaan lamang na ang paglikha ng isang string object gamit ang string tagapagbuo lumilikha ng isang bagay tulad ng uri ng Object , na behaves sa halos lahat ng oras tulad ng isang string.

564
05 июня '09 в 22:11 2009-06-05 22:11 sumagot sa Philippe Leybaert sa Hunyo 5, 2009 sa 10:11 2009-06-05 22:11

Isang kagiliw-giliw na graphical na representasyon ng paghahambing ng pagkakapantay-pantay sa pagitan ng == at === .

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


var1 === var2

Kapag gumagamit === upang subukan ang pagkakapantay sa JavaScript, ang lahat ay tulad nito. Wa>

2019

553
05 мая '14 в 8:21 2014-05-05 08:21 ang sagot ay ibinigay ng SNag noong Mayo 05 '14 sa 8:21 2014-05-05 08:21

Hayaan akong idagdag ang tip na ito:

Kung may pagdududa, basahin ang detalye !

Ang ECMA-262 ay isang pagtutukoy ng wika sa script kung saan ang JavaScript ay isang wika. Siyempre, sa pagsasagawa ito ay mahalaga kung paano ang pinakamahahalagang mga browser ay kumilos, sa halip na ang esoterikong kahulugan kung paano dapat isaayos ang isang bagay. Ngunit makakatulong na maunawaan kung bakit ang bagong String ("a")! == "isang" .

Mangyaring ipaalam sa akin kung paano basahin ang detalye upang linawin ang isyung ito. Nakita ko na sa napaka-lumang paksa na ito ay wa>

Ang paghahanap ng isang PDF file para sa === ay humahantong sa akin sa pahina 56 ng detalye: 11.9.4. Ang operator ay Mahigpit na Katumbas (===) , at pagkatapos na dumaan sa detalye, nakikita ko:

11.9.6 Algorithm para sa Paghahambing ng Mahigpit na Pagkapantay-pantay
Ang paghahambing ng x === y, kung saan ang x at y ay mga halaga, lumilikha ng totoo o hindi . Ang ganitong paghahambing ay ginaganap bi> 1. Kung ang Uri (x) ay naiiba mula sa Uri (y), bumalik mali .
2. Kung ang uri (x) ay Undefined, bumalik totoo .
3. Kung ang Uri (x) ay Null, bumalik totoo .
4. Kung ang Uri (x) ay hindi isang numero, laktawan sa hakbang 11.
5. Kung ang x ay NaN , bumalik mali .
6. Kung y ay NaN , bumalik mali .
7. Kung ang x ay ang parehong numerong halaga bi>totoo
.
8. Kung x ay +0 at y ay -0, bumalik totoo .
9. Kung x ay -0 at y ay +0, bumalik totoo .
10. Bumalik maling .
11. Kung ang Uri (x) ay String, bumalik totoo kung ang x at y ay eksakto ang magkaparehong pagkakasunud-sunod ng mga character (ang parehong haba at ang parehong mga character sa kauku>mali .
12. Kung ang Uri (x) ay boolean, bumalik totoo kung ang x at y ay parehong totoo o parehong mali ; sa kabi>mali .
13. Bumalik totoo kung ang x at y ay kabi>mali .

Ang stage 11 ay kagiliw-giliw. Oo, ang mga string ay itinuturing bi>bagong String ("a")! == "isang" . Mayroon ba kaming non-ECMA-262 browser?

Hindi napakabilis!

Tingnan ang mga uri ng operand. Subukan ito sa iyong sarili sa pamamagitan ng pambalot sa kanila sa typeof () . Natagpuan ko na ang bagong String ("a") ay isang bagay, at ang hakbang 1 ay ginamit: bumalik mali kapag naiiba ang mga uri.

Kung ikaw ay nagtataka kung bakit ang bagong String ("a") ay hindi nagbabalik ng isang string, paano ang tungkol sa i>


Isinulat ni Aidiakapi ito sa isang komento sa ibaba:

Mula sa pagtutukoy

11.2.2 Bagong operator :

Kung ang uri (constructor) ay hindi isang bagay, taasan ang isang Uri ng exception na Uri.

Sa ibang salita, kung ang String ay hindi sa uri ng Object, hindi ito magagamit sa bagong operator.

bagong laging nagbabalik ng isang bagay, kahit para sa mga constructor ng string . At sayang! Ang mga semantika ng halaga para sa mga string (tingnan ang Hakbang 11) ay nawala.

At sa wakas ito ay nangangahulugang: ang bagong String ("a")! == "isang" .

254
28 нояб. Ang sagot ay ibinigay nalty 28 nov. 2009-11-28 21:18 '09 sa 21:18 2009-11-28 21:18

Sa PHP at JavaScript, ito ay isang mahigpit na pagkakapantay-pantay na operator. Nangangahulugan ito na ito ay ihahambing ang uri at mga halaga.

95
12 мая '10 в 15:58 2010-05-12 15:58 ang sagot ay ibinigay ni Shiki noong Mayo 12, '10 sa 15:58 2010-05-12 15:58

Nasubukan ko ito sa Firefox gamit ang Firebug gamit ang sumusunod na code:

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

at

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

Ang aking mga resulta (naka-check limang beses at na-average):

 ==: 115.2 ===: 114.4 

Kaya, sasabihin ko na ang isang bahagyang pagkakaiba (ito ay higit sa 100,000 iteration, tandaan) ay hindi na mahalaga. Ang pagganap ay hindi ang dahilan === . Ang uri ng seguridad (mabuti, gaano kaligtas, kung papaano kayo pupunta sa javascript), at ang kalidad ng code.

91
25 дек. Ang sagot ay ibinigay ni Simon Scarfe noong Disyembre 25. 2008-12-25 14:17 '08 at 2:17 pm 2008-12-25 14:17

Sa JavaScript, nangangahulugan ito ng parehong halaga at uri.

Halimbawa

 4 == "4" // will return true 

ngunit

 4 === "4" // will return false 
88
12 мая '10 в 15:58 2010-05-12 15:58 ang sagot ay ibinigay ni Dimitar noong Mayo 12, '10 sa 15:58 2010-05-12 15:58

Ang operator ng === ay tinatawag na mahigpit na paghahambing ng operator, naiiba ito sa == operator.

Dalhin ang 2 vars a at b.

Para sa "isang == b" upang suriin ang katotohanan ng a at b ay dapat na isang halaga .

Sa kaso ng "a === b" a at b ay dapat na ang parehong halaga , pati na rin ang parehong uri para sa mga ito upang suriin ang katotohanan.

Kunin ang sumusunod na halimbawa

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

Sa konklusyon ; Ang paggamit ng == operator ay maaaring ma-rate bi>=== operator ay mas ligtas.

Sa 90% na sitwasyon ng paggamit, hindi mahalaga kung aling isa ang iyong ginagamit, ngunit makakatulong upang malaman ang pagkakaiba kapag nakakuha ka ng i>

77
11 дек. Ang sagot ay ibinigay sa pamamagitan ng Doctor Jones 11 Disyembre. 2008-12-11 17:58 '08 at 5:58 pm 2008-12-11 17:58

Sinusuri nito kung ang parehong panig ay pantay sa uri at halaga .

Halimbawa:

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

Pangkalahatang halimbawa:

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

Ang isa pang karaniwang halimbawa ay:

 null == undefined // returns "true", but in most cases a distinction is necessary 
70
12 мая '10 в 15:58 2010-05-12 15:58 ang sagot ay ibinigay ng vsync noong Mayo 12 '10 sa 15:58 2010-05-12 15:58

Bakit == kaya mahuhulaan?

Ano ang nakuha mo kapag inihambing mo ang wa>"" ang numero 0 0 ?

<code> Truecode>

Oo, ito ay tama alinsunod sa == wa>

At ito ay hindi nagtatapos dito, isa pa:

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

Ang mga bagay ay nagiging kakaiba sa mga arrays.

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

Pagkatapos ay mag-alis ng mga string

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

Mas masahol pa:

Kailan hindi katumbas ng?

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

Hayaan mo akong sabihin ulit ito:

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

At ito ay lamang ang mga nakatutuwang bagay na nakukuha mo sa mga primitibo.

Ito ay isang bagong antas ng kabaliwan kapag ginamit mo ang == sa mga bagay.

Sa puntong ito, malamang na magtaka ka ...

Bakit nangyayari ito?

Mabuti, dahil hindi tulad ng "triple equality" ( === ), na kung saan ay nagsusuri lamang kung ang dalawang halaga ay tumutugma.

== paggawa ng isang buong bungkos ng iba pang mga bagay .

Mayroon itong espesyal na pagproseso para sa mga function, espesyal na pagproseso para sa zero, hindi natukoy, mga string, na tinatawag mo.

Ito ay nakakakuha ng medyo pipi.

Sa katunayan, kung sinubukan mong magsulat ng isang function na ginagawa kung ano ang ginagawa nito == , magiging ganito ang ganito:

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

Kaya ano ang ibig sabihin nito?

Nangangahulugan ito na ang == ay kumplikado.

Dahil mahirap, mahirap maintindihan kung ano ang mangyayari kapag ginamit mo ito.

Nangangahulugan ito na maaaring magkaroon ka ng mga pagkakamali.

Kaya ang moral ng kuwento ...

Gawing mas komplikado ang iyong buhay.

Gamitin === halip ng == .

Ang wakas.

68
09 авг. ang sagot ay ibinigay ni Luis Perez 09 aug. 2016-08-09 19:50 '16 sa 7:50 ng 2016-08-09 19:50

Javascript execution sequence diagram para sa mahigpit na pagkakapantay-pantay / Paghahambing '==='

2019

05 сент. ang sagot ay binigyan ng Samar Panda 05 sep. 2015-09-05 16:53 '15 sa 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 ang sagot ay ibinigay ng user2496033 Hulyo 03 '13 sa 7:08 2013-07-03 07:08

Ang ibig sabihin nito ay pagkakapantay-pantay na wa> uri ng pamimilit. Ang uri ng pag-uugali ay nangangahulugan na ang JavaScript ay hindi awtomatikong nag-convert ng anumang iba pang mga uri ng data sa mga uri ng string ng data.

 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 ang sagot ay ibinigay ng Pop Catalin noong Mayo 12, '10 sa 15:59 2010-05-12 15:59

Sa isang tipikal na script ay wa>JavaScript profiler ay maaaring sabihin sa iyo kung may pagkakaiba sa pagganap sa iyong kaso.

Ngunit personal, gagawin ko kung ano ang nag-aalok ng JSLint. Ang rekomendasyon na ito ay hindi dahil sa mga isyu sa pagganap, ngunit dahil sa isang uri ng paghihigpit ('\t\r\n' == 0) .

46
16 дек. sumagot na ibinigay Constantin 16 dec. 2008-12-16 17:29 '08 at 5:29 pm 2008-12-16 17:29

Ang pantay na paghahambing ng operator == ay nalilito at dapat na iwasan.

Kung nakatira ka sa MAY , tandaan ang sumusunod na 3 bagay:

  • Ito ay hindi palipat: (a == b) at (b == c) ay hindi magreresulta sa (a == c)
  • Pinagsasama nito ang pagkakaunawaan nito: (a == b) at (a! = B) laging may kabaligtaran ng mga halaga ng Boolean sa lahat ng a at b.
  • Kapag may pag-aalin>

TALAAN NG KATARUNGANG OPERATOR SA JAVASCRIPT

  • Ang bawat hanay sa talahanayan ay isang hanay ng 3 magkaparehong "katumbas" na mga halaga, na nangangahulugan na ang anumang 2 mga halaga ng mga ito ay pantay na gamit ang kaparehong == * sign

** STRANGE: tandaan na ang anumang dalawang halaga sa unang hanay ay hindi katumbas sa kahulugan na ito. **

 '' == 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 сент. reply na ibinigay ni CuongHuyTo Sep 16 2011-09-16 17:25 '11 sa 17:25 2011-09-16 17:25

Mayroong halos anumang pagkakaiba sa pagganap sa pagitan ng dalawang operasyon sa iyong paggamit. Wa>

35
11 дек. sumagot na ibinigay Sean 11 Dis 2008-12-11 17:44 '08 sa 17:44 2008-12-11 17:44

Oo Mahalaga ito.

=== operator ng === sa javascript ay sumusuri sa halaga, pati na rin ang uri , kung saan ang operator == ay sumusuri lamang sa halaga (nag-convert ng uri kung kinakai> .

2019

35
14 нояб. Sagot na ibinigay ni Aniket Thakur Nobyembre 14 2014-11-14 09:02 '14 sa 9:02 2014-11-14 09:02
Operator

=== halaga ng tseke pati na rin ang mga uri ng mga variable para sa pagkakapantay-pantay.

Operator

== Sinusuri lamang ang halaga ng mga variable para sa pagkakapantay-pantay.

32
12 мая '10 в 16:03 2010-05-12 16:03 ang sagot ay ibinigay ni Niraj Choubey noong Mayo 12 '10 sa 16:03 2010-05-12 16:03

Ito ay isang mahigpit na pagsubok sa pagsubok.

Mabuti ito, lalo na kung nag-check ka sa pagitan ng 0 at false at null.

Halimbawa, kung mayroon kang:

 $a = 0; 

Pagkatapos:

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

Totoo ang lahat, at hindi mo ito nais. Ipagpalagay na mayroon kang isang function na maaaring ibalik ang 0th array index o false sa error. Kung titingnan mo ang kahon na may "==" false, makakakuha ka ng nakakalito na resulta.

Kaya, katulad ng nasa itaas, ngunit isang mahigpit na pagsubok:

 $a = 0; $a===0; // returns true $a===NULL; // returns false $a===false; // returns false 
30
12 мая '10 в 16:19 2010-05-12 16:19 Sagot ay binigyan Daniel 12 ng Mayo '10 sa 16:19 2010-05-12 16:19

Kung minsan, ang JSLint ay nagbibigay ng hindi makatotohanang mga dahilan para sa pagbabago ng materyal. === ay may parehong pagganap bi>== kung ang mga uri ay tumutugma.

Ito ay mas mabilis lamang kung ang mga uri ay hindi tumutugma, kung saan hindi ito nagtatangkang i-convert ang mga uri, ngunit nagbabalik mali.

Kaya, IMHO, JSLint maaaring magamit upang sumulat ng bagong code, ngunit wa>

Ibig sabihin, wa>== sa === sa isang pagsubok, halimbawa if (a == 'test') , kapag alam mo ito, dahil ang isang katotohanan ay maaari lamang maging isang String.

Ang pagbabago ng isang malaking halaga ng code sa ganitong paraan ay nangangai>

29
05 июня '12 в 10:53 2012-06-05 10:53 sumagot na ibinigay abo sa Hunyo 05 '12 sa 10:53 2012-06-05 10:53

Lamang

== nangangahulugang isang paghahambing sa pagitan ng mga operand sa type conversion

=== nangangahulugang isang paghahambing sa pagitan ng mga operandong wa> type conversion

Ang pag-type ng conversion sa javaScript ay nangangahulugang javaScript awtomatikong nag-convert ng anumang iba pang mga uri ng data sa mga string ng mga uri ng data.

Halimbawa:

 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 sagot ay ibinigay Amit Marso 20, '15 sa 8:05 2015-03-20 08:05

Ang isang simpleng halimbawa ay

 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 ang sagot ay ibinigay ni Vikas noong Mayo 14 '15 sa 17:45 2015-05-14 17:45

Ang mga top 2 na sagot para sa parehong nabanggit == ay nangangahulugan ng pagkakapantay at === nangangahulugang tagatukoy. Sa kasamaang palad, ang pahayag na ito ay hindi tama.