Ik gebruik JSLint om door JavaScript te gaan, en het geeft veel suggesties om ==
(twee gelijk-tekens) te vervangen door ===
(drie gelijk-tekens) bij het doen van dingen zoals het vergelijken van idSele_UNVEHtype.value.length == 0
binnen een if
verklaring.
Is er een prestatievoordeel aan het vervangen van ==
door ==
?
Elke prestatieverbetering zou welkom zijn, aangezien er veel vergelijkingsoperatoren bestaan.
Als er geen type conversie plaatsvindt, zou er dan een prestatiewinst zijn ten opzichte van ==
?
De identiteit (==
) operator gedraagt zich identiek aan de gelijkheid (==
) operator, behalve dat er geen type conversie wordt gedaan, en dat de types hetzelfde moeten zijn om als gelijk beschouwd te worden.
Referentie: Javascript Tutorial: Comparison Operators
De ==
operator zal vergelijken voor gelijkheid na het doen van eventuele noodzakelijke type conversies. De ==
operator zal niet de conversie doen, dus als twee waarden niet van hetzelfde type zijn zal ==
simpelweg vals
teruggeven. Beide zijn even snel.
Om Douglas Crockford's uitstekende JavaScript: The Good Parts te citeren,
JavaScript heeft twee sets van gelijkheids operatoren:
==
en!==
, en hun slechte tweeling==
en!=
. De goede operatoren werken zoals je zou verwachten. Als de twee operanden van hetzelfde type zijn en dezelfde waarde hebben, dan produceert==
true
en!==
produceertfalse
. De kwade tweeling doet het goed als de operanden van hetzelfde type zijn, maar als ze van verschillende types zijn, proberen ze de waarden te dwingen. De regels waarmee ze dat doen zijn ingewikkeld en onherinnerbaar. Dit zijn enkele van de interessante gevallen:
'' == '0' // false 0 == '' // true 0 == '0' // true
false == 'false' // false false == '0' // true
false == undefined // false vals == null // vals null == ongedefinieerd // true
' ' == 0 // true
Het gebrek aan transitiviteit is alarmerend. Mijn advies is om nooit de slechte tweeling te gebruiken. Gebruik in plaats daarvan altijd
===
en!==
. Alle vergelijkingen die net getoond zijn, producerenvalse
met de==
operator.
Een goed punt werd naar voren gebracht door @Casebash in de commentaren en in @Phillipe Laybaert's antwoord betreffende referentietypes. Voor referentietypes geldt dat ==
en ===
consistent met elkaar handelen (behalve in een speciaal geval).
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
Het speciale geval is wanneer je een letterlijke vergelijkt met een object dat evalueert naar dezelfde letterlijke, als gevolg van zijn toString
of valueOf
methode. Neem bijvoorbeeld de vergelijking van een string letterlijk met een string object aangemaakt door de String
constructor.
"abc" == new String("abc") // true
"abc" === new String("abc") // false
Hier controleert de ==
operator de waarden van de twee objecten en geeft true
terug, maar de ===
ziet dat ze'niet van hetzelfde type zijn en geeft false
terug. Welke is juist? Dat hangt er echt van af wat je probeert te vergelijken. Mijn advies is om de vraag helemaal te omzeilen en gewoon de String
constructor niet te gebruiken om string objecten te maken.
Referentie http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3
Gebruik van de ==
operator (Gelijkheid)
true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2; //true, because "2" is converted to 2 and then compared
Gebruik van de ==
operator (Identiteit)
true === 1; //false
"2" === 2; //false
Dit komt omdat de equality operator ==
aan type coercion doet, wat betekent dat de interpreter impliciet probeert om de waarden te converteren alvorens te vergelijken.
Aan de andere kant doet de identity operator ==
geen type coercion, en converteert de waarden dus niet bij het vergelijken, en is daarom sneller (volgens de This JS benchmark test) omdat het een stap overslaat.
Het is onwaarschijnlijk dat er een verschil in prestatie zal zijn tussen de twee operaties in uw gebruik. Er is geen type-conversie nodig omdat beide parameters al van hetzelfde type zijn. Beide operaties zullen een type-vergelijking hebben, gevolgd door een waarde-vergelijking.