ECMAScript ekvivalenta operatorer

Att avgöra om två variabler är lika är en mycket viktig operation i programutveckling. När det gäller ursprungliga värden är denna operation ganska enkel, men när det gäller objekt blir uppgiften något mer komplex.

ECMAScript erbjuder två uppsättningar ekvivalensoperatorer: likhetstecken och olikhetstecken används för att hantera ursprungliga värden, och helt likhetstecken och helt olikhetstecken används för att hantera objekt.

Likhetstecken och olikhetstecken

I ECMAScript representeras likhetstecknet av dubbel likhetstecken (==), och det returnerar true när och endast när de två operanterna är lika. Olikhetstecknet representeras av utropstecken plus likhetstecken (!=), och det returnerar true när och endast när de två operanterna är olika. För att avgöra om två operanter är lika, utför båda operatorn typkonvertering.

Reglerna för att utföra typkonvertering är följande:

  • Om en av operanterna är ett Boolean-värde, konverteras det till ett numeriskt värde innan ekvivalens kontrolleras. false konverteras till 0, true till 1.
  • Om en av operanterna är en sträng och den andra är ett tal, försöker man konvertera strängen till ett tal innan ekvivalens kontrolleras.
  • Om en av operanterna är ett objekt och den andra är en sträng, försöker man konvertera objektet till en sträng innan ekvivalens kontrolleras.
  • Om en av operanterna är ett objekt och den andra är ett tal, försöker man konvertera objektet till ett tal innan ekvivalens kontrolleras.

När jämförelse görs följer operatorn följande regler:

  • Värdena null och undefined är lika.
  • När du kontrollerar ekvivalens får du inte konvertera null och undefined till andra värden.
  • Om någon av operanterna är NaN, returnerar likhetstecknet false, och olikhetstecknet returnerar true.
  • Om båda operanterna är objekt, jämförs deras referensvärden. Om båda operanterna pekar på samma objekt, returnerar likhetstecknet true, annars är de två operanterna olik.

Viktigt tips:Även om båda talen är NaN, returnerar likhetstecknet false eftersom enligt reglerna är NaN inte lika med NaN.

Följande tabell listar några speciella fall och deras resultat:

uttryck värde
null == undefined true
"NaN" == NaN false
5 == NaN false
NaN == NaN false
NaN != NaN true
false == 0 true
true == 1 true
true == 2 false
undefined == 0 false
null == 0 false
"5" == 5 true

Fullt olikhetstecken och inte fullt olikhetstecken

Likhetstecknet och olikhetstecknet är samma som fullt olikhetstecknet och inte fullt olikhetstecknet. Dessa operatorer gör samma sak som likhetstecknet och olikhetstecknet, men de utför ingen typskonvertering innan de kontrollerar ekvivalenten.

Fullt olikhetstecken representeras av tre likhetstecken (===), och returnerar true endast när operanderna är lika utan att behöva konverteras.

Exempel:

var sNum = "66";
var iNum = 66;
alert(sNum == iNum);	//Utskrift "true"
alert(sNum === iNum);	//Utskrift "false"

I denna kod använder den första alert-användningen likhetstecken för att jämföra strängen "66" med talet 66 och skriver ut "true". Som nämnts tidigare är detta för att strängen "66" kommer att konverteras till talet 66 innan den jämförs med den andra talet 66. Den andra alert-användningen använder fullt olikhetstecken för att jämföra sträng och tal utan någon typskonvertering, naturligtvis är strängen inte lika med talet, så utskriften är "false".

Olikhetstecknet är representerat av ett utropstecken och två likhetstecken (!==), och returnerar true endast när operanderna inte behöver konverteras och är olikartade.

Exempel:

var sNum = "66";
var iNum = 66;
alert(sNum != iNum);	//Utskrift "false"
alert(sNum !== iNum);	//Utskrift "true"

Här, den första alert-användningen använder olikhetstecken, konverterar strängen "66" till talet 66, så att den är lika med den andra operanden 66. Därför är resultatet "false", eftersom de två operanderna är lika. Den andra alert-användningen använder inte helt olikhetstecken. Operationen frågar: "Är sNum och iNum olika?" Svaret på denna fråga är: ja (true), eftersom sNum är en sträng och iNum är ett tal, de är naturligtvis olika.