Operatori di confronto JavaScript: identità vs. uguaglianza

Question

Ho cercato di capire la differenza tra gli operatori di confronto di JavaScript: identità e uguaglianza. Da quello che ho letto, se controlli l'uguaglianza di due oggetti usando ==, JavaScript proverà a capire se hanno lo stesso tipo e, in caso contrario, prova a portarli allo stesso tipo. Tuttavia, === non si comporta allo stesso modo. Quindi, come esempio:

var n = "1";
console.log(n==1);        // outputs true
console.log(n===1);       // outputs false

Allora qual è la differenza tra questi operatori di "identità" e gli operatori di uguaglianza regolare? Qual è il vantaggio di avere entrambi?

Ci sono differenze nelle prestazioni? Penserei che l'operatore di identità sarebbe più veloce poiché non fa conversione.

Inoltre, in che modo differiscono quando si tratta di oggetti più complessi, come array? Ancora più importante, cosa dicono le convenzioni su quando si dovrebbe essere usata sull'altro, perché?

Answer 1

L'operatore di uguaglianza tenterà di rendere gli utenti i tipi di dati prima di fare il confronto. D'altra parte, l'operatore di identità richiede che entrambi i tipi di dati siano gli stessi di un prerequisito.

Ci sono alcuni altri post là fuori simili a questi domande. Vedere:

In che modo gli operatori di confronto per l'uguaglianza PHP (== doppia) e l'identità (=== triple eguali)? (ha un bel grafico di confronto)
Quale uguale operatore (== vs ===) dovrebbe essere usato nei confronti JavaScript?

In pratica, l'operatore di identità è davvero utile quando vuoi essere sicuro che un valore booleano sia vero o falso poiché ...

1 == true     => true
true == true  => true
1 === true    => false
true === true => true

Answer 2

La differenza è che ==, <=,> = e! = Farà la coercizione del tipo - ad esempio, costringe una stringa da valutare come numero. ===, <==,> ==, e! == non farà la coercizione del tipo. Confronteranno una stringa con un numero e poiché la stringa "1" non è la stessa del valore numerico 1, il risultato è falso.

Il riferimento è qui:
https://developer.mozilla.org/en/javascript/reference/operator/comparison_operator

Answer 3

== è le stesse cose di ===, salvo che == Digita la conversione

Per mostrarti cosa intendo qui è una funzione JavaScript che si comporta esattamente come ==:

// loseEqual() behaves just like `==`
function loseEqual(x, y) {
    // notice the function only uses "strict" operators 
    // like `===` and `!==` to do comparisons

    if(typeof y === typeof x) return y === x;

    if(typeof y === "function" || typeof x === "function") return false;

    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if(typeof x === "object") x = toPrimitive(x);
    if(typeof y === "object") y = toPrimitive(y);

    if(typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the "+" trick
    if(typeof x !== "number") x = +x;
    if(typeof y !== "number") y = +y;

    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

Questa funzione dovrebbe aiutare a spiegare perché le persone continuano a dire che non dovresti usare ==.

Come potete vedere == Ha molta logica complicata per la conversione del tipo. Per questo motivo è difficile prevedere quale risultato otterrai - e questo può portare a bug.

Ecco alcuni esempi di alcuni risultati che non ti aspetteresti:

Verità inaspettate

[1] == true // returns true
'0' == false // returns true
[] == false // returns true
[[]] == false // returns true
[0] == false // returns true

'\r\n\t' == 0 // returns true

Conclusioni inaspettate

// IF an empty string '' is equal to the number zero (0)
'' == 0 // return true

// AND the string zero '0' is equal to the number zero (0)
'0' == 0 // return true

// THEN an empty string must be equal to the string zero '0'
'' == '0' // returns **FALSE**

Oggetti con funzioni speciali

// Below are examples of objects that
// implement `valueOf()` and `toString()`

var objTest = {
    toString: function() {
        return "test";
    }
};

var obj100 = {
    valueOf: function() {
        return 100;
    }
};

var objTest100 = {
    toString: function() {
        return "test";
    },
    valueOf: function() {
        return 100;
    }
};

objTest == "test" // returns true
obj100 == 100 // returns true
objTest100 == 100 // returns true

objTest100 == "test" // returns **FALSE**

Answer 4

Il motivo è che l'identità o l'operatore rigoroso (===), si confronta con nessuna conversione di tipo, ciò significa che se entrambi i valori non hanno lo stesso valore e lo stesso tipo, non saranno considerati uguali.

Una spiegazione più chiara nel seguente link:

https://medium.com/@ludico8/Identity-vs-quality-battle-of-understanding-vs-758d396e922#.hhg396ey9