¿Qué operador igual (== vs ===) debería usarse en las comparaciones de JavaScript?

El operador de igualdad estricta ( ===) se comporta de manera idéntica al operador de igualdad abstracta ( ==), excepto que no se realiza ninguna conversión de tipos y los tipos deben ser los mismos para que se consideren iguales.

Referencia: Tutorial de JavaScript: operadores de comparación

El ==operador comparará la igualdad después de realizar las conversiones de tipos necesarias . El ===operador no realizará la conversión, por lo que si dos valores no son del mismo tipo ===simplemente devolverá false. Ambos son igualmente rápidos.

Para citar el excelente JavaScript de Douglas Crockford : The Good Parts ,

JavaScript tiene dos conjuntos de operadores de igualdad: ===y !==y sus gemelos malvados ==y !=. Los buenos funcionan como cabría esperar. Si los dos operandos son del mismo tipo y tienen el mismo valor, entonces ===produce truey !==produce false. Los gemelos malvados hacen lo correcto cuando los operandos son del mismo tipo, pero si son de diferentes tipos, intentan coaccionar los valores. Las reglas por las que lo hacen son complicadas e inolvidables. Estos son algunos de los casos interesantes:

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

La falta de transitividad es alarmante. Mi consejo es que nunca uses a los gemelos malvados. En su lugar, utilice siempre ===y !==. Todas las comparaciones que se acaban de mostrar se producen falsecon el ===operador.

Actualizar

@Casebash mencionó un buen punto en los comentarios y en la respuesta de @Phillipe Laybaert sobre los objetos. Para objetos, y actúan coherentemente unos con otros (salvo caso especial).=====

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

El caso especial es cuando se compara una primitiva con un objeto que se evalúa como la misma primitiva, debido a su método toStringo valueOf. Por ejemplo, considere la comparación de una cadena primitiva con un objeto de cadena creado usando el Stringconstructor.

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

Aquí el ==operador verifica los valores de los dos objetos y regresa true, pero ===ve que no son del mismo tipo y regresa false. ¿Cuál es correcto? Eso realmente depende de lo que intentes comparar. Mi consejo es omitir la pregunta por completo y simplemente no usar el Stringconstructor para crear objetos de cadena a partir de literales de cadena.

Referencia
https://262.ecma-international.org/5.1/#sec-11.9.3

Dec 11 '2008 14:12 Bill the Lizard