Operadores de comparación de JavaScript: Identidad vs. Igualdad

Question

He estado tratando de comprender la diferencia entre los operadores de comparación de JavaScript: identidad e igualdad. Por lo que he leído, si comprueba la igualdad de dos objetos usando ==, JavaScript tratará de averiguar si son del mismo tipo y, si no, intente obtenerlos del mismo tipo. Sin embargo, === no se comporta de la misma manera. A modo de ejemplo:

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

Entonces, ¿cuál es la diferencia entre estos operadores de "identidad" y los operadores regulares de igualdad? ¿Cuál es el beneficio de tener ambos?

¿Hay diferencias en el rendimiento? Creo que el operador de identidad sería más rápido ya que no hace la conversión.

Además, ¿cómo difieren cuando se trata de objetos más complejos, como matrices? Lo que es más importante, ¿qué dicen las convenciones sobre cuándo se debe usar uno sobre el otro? ¿Por qué?

Answer 1

El operador de igualdad intentará realizar los tipos de datos de la misma antes de hacer la comparación. Por otro lado, el operador de identidad requiere que ambos tipos de datos sean iguales a un requisito previo.

Hay bastantes otros mensajes similares a estas preguntas. Ver:

How do the PHP equality (== double equals) and identity (=== triple equals) comparison operators differ? (tiene una buena tabla comparativa)
Which equals operator (== vs ===) should be used in JavaScript comparisons?

En la práctica, el operador identidad viene en muy práctico cuando se desea estar seguro de que un valor booleano es verdadero o falso, ya ...

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

Answer 2

La diferencia es que ==, < =,> = y! = Hará una coerción de tipo — por ejemplo, forzar una cadena para ser evaluada como un número. ===, < ==,> == y! == no hará coerción de tipo. Compararán una cadena con un número, y como la cadena "1" no es igual que el valor numérico 1, el resultado es falso.

aquí se hace referencia:
https://developer.mozilla.org/en/JavaScript/Reference/Operators/Comparison_Operators

Answer 3

La razón es que la identidad o el operador estricto (===), se compara con ninguna conversión de tipo, eso significa que si ambos valores no tienen el mismo valor y el mismo tipo, no se considerarán igual.

Una más clara explicación en el siguiente enlace:

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

Answer 4

== es lo mismo que ===, excepto que == no escriba conversión

Para mostrar lo que quiero decir aquí es una función de JavaScript que se comporta exactamente como ==:

// 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(); 
} 

Esta función debería ayudar a explicar por qué la gente sigue diciendo que no debe usar ==.

Como puede ver == tiene mucha lógica complicada para la conversión de tipos.Por eso es difícil predecir qué resultado obtendrás, y eso puede provocar errores.

Éstos son algunos ejemplos de algunos resultados que no esperaba:

verdades inesperadas

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

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

Conclusiones inesperados

// 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** 

Objetos con funciones especiales

// 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**