0 szavazat
(4,8e pont) által 
által újranyitott

JSLint-et használok JavaScript kódellenőrzésre és sok olyan javaslattal tér vissza, hogy helyettesítsem a == (két egyenlőségjelet) === (három egyenlőségjellel) miközben a idSele_UNVEHtype.value.length == 0 hasonlítom össze egy if feltételben.

Van teljesítménybeli előnye a ==-t ===-vel helyettesíteni?

Minden teljesítménybeli javulásnak örülök, mert sok ilyen összehasonlításom van.

Ha nincs típus konverzió, lenne teljesítmény javulás a ==-vel szemben?

1 válasz

0 szavazat
(4,8e pont) által 
 
Legjobb válasz

Az azonosság (===) operátor ugyanúgy működik mind az egyenlőség (==) operátor, azt leszámítva, hogy nincs típus konverzió, és a típusoknak is meg kell egyezniük, ahhoz, hogy egyenlőnek számítsanak.

A == operátor azután hasonlítja össze az értékeket, hogy egyenlőek-e, miután átkonvertálta az egyik típusát szükség esetén.
A === operátor nem csinál típus konverziót. Ha a két érték nem ugyanolyan típusú, akkor a === simán false-szal tér vissza. Mind a kettő egyformán gyors.

Példák a == működésére:

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

Az elöbbi példák mindegyike false-szal térne vissza ha ==-helyett ===-t használnánk.

Referencia típusokra a == és a === ugyanúgy működik (leszámítva a különleges helyzeteket):

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

Speciális eset, amikor literal-t hasonlítasz össze objektummal, aminek az értéke ugyanaz a literal toString vagy valueOf esetén. Például, amikor összehasonlítasz egy string literalt egy string objektummal, ami a String konstruktorral készült:

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

Itt a == operátor megnézni a két értéket és true-val tér vissza, de a === azt látja, hogy nem azonos a típusuk és false-szal tér vissza. Hogy melyik helyes? Attól függ miket akarsz összehasonlítani. A javaslatom, hogy ne használj Ṡtring` konstruktort string objektumok létrehozásához.

...