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

Estoy usando JSLint para pasar por JavaScript, y está devolviendo muchas sugerencias para reemplazar == (dos signos iguales) con === (tres signos iguales) al hacer cosas como comparar idSele_UNVEHtype.value.length == 0 dentro de un if .

¿Hay algún beneficio de rendimiento al reemplazar == con ===?

Cualquier mejora en el rendimiento sería bienvenida, ya que existen muchos operadores de comparación.

Si no se lleva a cabo ninguna conversión de tipo, ¿habría una ganancia de rendimiento sobre ==?

preguntado el 11 de diciembre de 08 a las 15:12

30 Respuestas

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

Referencia: Tutorial de Javascript: Operadores de comparación

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

Para citar la excelente obra de Douglas Crockford JavaScript: las partes buenas,

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 true y !== 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 y poco memorables. 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

Tabla de comparación de igualdad

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 producen false con === operador.


Actualizar:

Un buen punto fue planteado por @Casebash en los comentarios y en @Phillipe Laybaert's https://www.youtube.com/watch?v=xB-eutXNUMXJtA&feature=youtu.be en relación con los objetos. Para objetos, == y === actuar de forma coherente entre sí (excepto en un 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 toString or valueOf método. Por ejemplo, considere la comparación de una primitiva de cadena con un objeto de cadena creado usando el String constructor.

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

Aquí el == El operador comprueba los valores de los dos objetos y devuelve true, Pero el === es ver que no son del mismo tipo y volver false. Cual es la correcta? Eso realmente depende de lo que intente comparar. Mi consejo es que omita la pregunta por completo y no utilice la String constructor para crear objetos de cadena a partir de literales de cadena.

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

contestado el 24 de mayo de 20 a las 20:05

También señalaría que 0 === -0 y NaN! == NaN, lo que a veces puede resultar confuso. Si desea diferenciar ± 0 y considerar los NaN iguales, use Object.is (ES2015) - Ovinus Real

Usando el patrón de velas del == operadorIgualdad)

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Usando el patrón de velas del === operadorCorporativa)

true === 1; //false
"2" === 2;  //false

Esto es porque el operador de igualdad == ¿escribe coerción?, lo que significa que el intérprete intenta implícitamente convertir los valores antes de comparar.

Por otro lado, la operador de identidad === no hace tipo de coerción, y por lo tanto no convierte los valores al comparar, y por lo tanto es más rápido (según Este punto de referencia de JS prueba) ya que salta un paso.

Respondido 29 Abr '19, 04:04

Una interesante representación pictórica de la comparación de igualdad entre == y ===.

Fuente: http://dorey.github.io/JavaScript-Equality-Table/


var1 === var2

Cuando usas === para las pruebas de igualdad de JavaScript, todo es como está. Nada se convierte antes de ser evaluado.

Evaluación de igualdad de === en JS


var1 == var2

Cuando usas == para las pruebas de igualdad de JavaScript, se producen algunas conversiones extravagantes.

Evaluación de igualdad de == en JS

Moraleja de la historia:

Utilizan === a menos que comprenda completamente las conversiones que tienen lugar con ==.

Respondido 13 Jul 18, 20:07

En las respuestas aquí, no leí nada sobre lo que igual medio. Algunos dirán que === significa igual y del mismo tipo, pero eso no es realmente cierto. En realidad significa que ambos operandos hacen referencia al mismo objeto, o en caso de tipos de valor, tienen el mismo valor.

Entonces, tomemos el siguiente código:

var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Lo mismo aquí:

var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

O incluso:

var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

Este comportamiento no siempre es obvio. Hay más en la historia que ser iguales y ser del mismo tipo.

La regla es:

Para tipos de valor (números):
a === b devuelve verdadero si a y b tienen el mismo valor y son del mismo tipo

Para tipos de referencia:
a === b devuelve verdadero si a y b hacer referencia al mismo objeto exacto

Para cuerdas:
a === b devuelve verdadero si a y b son cadenas y contienen exactamente los mismos caracteres


Cuerdas: el caso especial ...

Las cadenas no son tipos de valor, pero en Javascript se comportan como tipos de valor, por lo que serán "iguales" cuando los caracteres de la cadena sean iguales y cuando tengan la misma longitud (como se explica en la tercera regla)

Ahora se vuelve interesante:

var a = "12" + "3";
var b = "123";

alert(a === b); // returns true, because strings behave like value types

¿Pero qué tal esto ?:

var a = new String("123");
var b = "123";

alert(a === b); // returns false !! (but they are equal and of the same type)

Pensé que las cadenas se comportan como tipos de valor. Bueno, depende de a quién le preguntes ... En este caso ayb no son del mismo tipo. a es de tipo Object, mientras b es de tipo string. Solo recuerde que crear un objeto de cadena usando el String constructor crea algo de tipo Object que se comporta como una cuerda la mayor parte del tiempo.

Respondido el 20 de junio de 20 a las 12:06

Permítanme agregar este consejo:

En caso de duda, lea el especificación!

ECMA-262 es la especificación de un lenguaje de secuencias de comandos del que JavaScript es un dialecto. Por supuesto, en la práctica importa más cómo se comportan los navegadores más importantes que una definición esotérica de cómo se supone que se debe manejar algo. Pero es útil comprender por qué new String ("a")! == "a".

Permítame explicarle cómo leer la especificación para aclarar esta pregunta. Veo que en este tema tan antiguo nadie tenía una respuesta para el efecto tan extraño. Entonces, si puede leer una especificación, esto lo ayudará enormemente en su profesión. Es una habilidad adquirida. Entonces, continuemos.

La búsqueda del archivo PDF para === me lleva a la página 56 de la especificación: 11.9.4. El operador estricto igual (===), y después de leer las especificaciones, encuentro:

11.9.6 El algoritmo de comparación de igualdad estricta
La comparación x === y, donde xey son valores, produce verdadero or false. Esta comparación se realiza de la siguiente manera:
  1. Si el tipo (x) es diferente del tipo (y), devuelva false.
  2. Si el tipo (x) no está definido, devuelva verdadero.
  3. Si Type (x) es Null, devuelve verdadero.
  4. Si Tipo (x) no es Número, vaya al paso 11.
  5. Si x es Yaya, regreso false.
  6. Si y es Yaya, regreso false.
  7. Si x es el mismo valor numérico que y, devuelve verdadero.
  8. Si x es +0 e y es −0, devuelve verdadero.
  9. Si x es −0 e y es +0, devuelve verdadero.
  10. Regreso false.
  11. Si Type (x) es String, devuelve verdadero si xey son exactamente la misma secuencia de caracteres (la misma longitud y los mismos caracteres en las posiciones correspondientes); de lo contrario, regresa false.
  12. Si Type (x) es booleano, devuelve verdadero si xey son ambos verdadero o ambos false; de lo contrario, regresa false.
  13. Regreso verdadero si xey se refieren al mismo objeto o si se refieren a objetos unidos entre sí (véase 13.1.2). De lo contrario, regresa false.

El paso 11 es interesante. Sí, las cadenas se tratan como tipos de valor. Pero esto no explica por qué new String ("a")! == "a". ¿Tenemos un navegador que no cumple con ECMA-262?

¡No tan rapido!

Comprobemos los tipos de operandos. Pruébelo usted mismo envolviéndolos en tipo de(). encontré eso nueva cadena ("a") es un objeto, y se usa el paso 1: return false si los tipos son diferentes.

Si te preguntas porque nueva cadena ("a") no devuelve una cadena, ¿qué tal un ejercicio de lectura de una especificación? ¡Divertirse!


Aidiakapi escribió esto en un comentario a continuación:

De la especificación

11.2.2 El nuevo operador:

Si Type (constructor) no es Object, lanza una excepción TypeError.

En otras palabras, si String no fuera del tipo Object, no podría usarse con el operador new.

Un nuevo siempre devuelve un objeto, incluso para Cordón también constructores. ¡Y ay! Se pierde la semántica del valor de las cadenas (consulte el paso 11).

Y esto finalmente significa: new String ("a")! == "a".

Respondido el 20 de junio de 20 a las 12:06

Probé esto en Firefox con Firebug usando un código como este:

console.time("testEquality");
var n = 0;
while (true) {
  n++;
  if (n == 100000)
    break;
}
console.timeEnd("testEquality");

y

console.time("testTypeEquality");
var n = 0;
while (true) {
  n++;
  if (n === 100000)
    break;
}
console.timeEnd("testTypeEquality");

Mis resultados (probados cinco veces cada uno y promediados):

==: 115.2
===: 114.4

Entonces diría que la diferencia minúscula (esto es más de 100000 iteraciones, recuerde) es insignificante. Actuación no es una razón para hacer ===. Escriba seguridad (bueno, tan seguro como lo obtendrá en JavaScript), y la calidad del código es.

respondido 11 nov., 20:17

Ahora, ¿cómo se comparan estos cuando hay una coersión de tipo real para == ¿operador? Recuerde, ahí es cuando hay un aumento de rendimiento. - Hubert OG

MAYOR diferencia cuando se prueba correctamente por las razones antes mencionadas de más rápido para verificar solo la desigualdad de tipos. jsfiddle.net/4jhuxkb2 - Doug Morrow

Mide el rendimiento de algo como esto en operaciones / segundo, no una sola prueba en un solo navegador (uno con aproximadamente el 5% de participación de mercado) usando console.time () mientras usa una prueba que no toma coerción de tipo (la razón completa es más lento) en cuenta. Esta es una prueba completamente sin sentido. Tiene razón en que el rendimiento no es la razón para usar === encima == pero te equivocas en que su desempeño es esencialmente igual y que pensarías que esta prueba prueba eso, y que muchas otras personas estuvieron de acuerdo, es totalmente absurdo para mí. - Stephen M. Irving

En PHP y JavaScript, es un operador de igualdad estricto. Lo que significa que comparará tanto el tipo como los valores.

contestado el 12 de mayo de 10 a las 16:05

En JavaScript significa del mismo valor y tipo.

Por ejemplo,

4 == "4" // will return true

, pero

4 === "4" // will return false 

Respondido 26 Oct 14, 14:10

Al === operador se llama un operador de comparación estricto, diferir de la == operador.

Tomemos 2 vars ay b.

Ayudas "a == b" para evaluar a verdadero ayb necesita ser el mismo valor.

En el caso de los "a === b" ayb deben ser los mismo valor y también el el mismo tipo para que se evalúe como verdadero.

Toma el siguiente ejemplo

var a = 1;
var b = "1";

if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}

if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}

En resumen; utilizando la == El operador puede evaluar como verdadero en situaciones en las que no desea que lo haga, por lo que === operador sería más seguro.

En el escenario de uso del 90%, no importa cuál use, pero es útil saber la diferencia cuando tiene algún comportamiento inesperado algún día.

Respondido 21 ago 13, 12:08

Por qué == es tan impredecible?

¿Qué obtienes cuando comparas una cadena vacía? "" con el numero cero 0?

true

Sí, eso es correcto según == una cadena vacía y el número cero son la misma hora.

Y no termina ahí, aquí hay otro:

'0' == false // true

Las cosas se ponen realmente raras con las matrices.

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

Entonces más raro con cuerdas

[1,2,3] == '1,2,3' // true - REALLY?!
'\r\n\t' == 0 // true - Come on!

Se pone peor:

¿Cuándo es igual no igual?

let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string

A == B // true - ok... 
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!

Déjame decirlo de nuevo:

(A == B) && (B == C) // true
(A == C) // **FALSE**

Y estas son solo las locuras que se obtienen con las primitivas.

Es un nivel completamente nuevo de locura cuando usas == con objetos.

En este punto probablemente se esté preguntando ...

¿Por qué sucede esto?

Bueno, es porque a diferencia de "triple es igual" (===) que solo verifica si dos valores son iguales.

== hace un un montón de otras cosas.

Tiene manejo especial para funciones, manejo especial para nulos, indefinidos, cadenas, lo que sea.

Se vuelve bastante loco.

De hecho, si intenta escribir una función que haga lo que == ¿Se vería algo como esto?

function isEqual(x, y) { // if `==` were a function
    if(typeof y === typeof x) return y === x;
    // 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 y === "function" || typeof x === "function") {
        // if either value is a string 
        // convert the function into a string and compare
        if(typeof x === "string") {
            return x === y.toString();
        } else if(typeof y === "string") {
            return x.toString() === y;
        } 
        return false;
    }

    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;
    // actually the real `==` is even more complicated than this, especially in ES6
    return x === y;
}

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

Entonces, ¿qué significa esto?

Significa == es complicado.

Debido a que es complicado, es difícil saber qué pasará cuando lo uses.

Lo que significa que podría terminar con errores.

Entonces la moraleja de la historia es ...

Haz tu vida menos complicada.

Utilizan === en lugar de ==.

El fin

Respondido 21 Abr '18, 18:04

=== comprueba que los mismos lados son iguales en tipo así como también a VALORAMOS.


Ejemplo:

'1' === 1 // will return "false" because `string` is not a `number`

Ejemplo común:

0 == ''  // will be "true", but it's very common to want this check to be "false"

Otro ejemplo común:

null == undefined // returns "true", but in most cases a distinction is necessary

Muchas veces un sin tipo El cheque sería útil porque no le importa si el valor es undefined, null, 0 or ""

Respondido el 20 de junio de 20 a las 12:06

Diagrama de flujo de ejecución de Javascript para igualdad / comparación estricta '==='

Igualdad estricta de JavaScript

Diagrama de flujo de ejecución de Javascript para igualdad / comparación no estricta '=='

No igualdad de JavaScript

Respondido el 05 de Septiembre de 15 a las 16:09

JavaScript === vs == .

0==false   // true
0===false  // false, because they are of a different type
1=="1"     // true, auto type coercion
1==="1"    // false, because they are of a different type

respondido 12 nov., 15:06

Significa igualdad sin coerción de tipo la coerción de tipos significa que JavaScript no convierte automáticamente ningún otro tipo de datos en tipos de datos de cadena

0==false   // true,although they are different types

0===false  // false,as they are different types

2=='2'    //true,different types,one is string and another is integer but 
            javaScript convert 2 to string by using == operator 

2==='2'  //false because by using === operator ,javaScript do not convert 
           integer to string 

2===2   //true because both have same value and same types 

Respondido 31 Jul 17, 00:07

En un script típico no habrá diferencia de rendimiento. Más importante puede ser el hecho de que mil "===" pesa 1 KB más que mil "==" :) Generadores de perfiles de JavaScript puede decirle si hay una diferencia de rendimiento en su caso.

Pero personalmente haría lo que sugiere JSLint. Esta recomendación no se debe a problemas de rendimiento, sino a que el tipo de coerción significa ('\t\r\n' == 0) es verdad.

contestado el 23 de mayo de 17 a las 15:05

El operador de comparación igual == es confuso y debe evitarse.

Si TIENE QUE vive con eso, luego recuerda las siguientes 3 cosas:

  1. No es transitivo: (a == b) y (b == c) no conduce a (a == c)
  2. Es mutuamente excluyente de su negación: (a == b) y (a! = b) siempre mantenga valores booleanos opuestos, con todo ay b.
  3. En caso de duda, aprenda de memoria la siguiente tabla de verdad:

TABLA DE VERDAD DE OPERADORES IGUALES EN JAVASCRIPT

  • Cada fila de la tabla es un conjunto de 3 valores mutuamente "iguales", lo que significa que 2 valores cualesquiera entre ellos son iguales usando el signo igual == *

** EXTRAÑO: tenga en cuenta que dos valores cualesquiera en la primera columna no son iguales en ese sentido. **

''       == 0 == false   // Any two values among these 3 ones are equal with the == operator
'0'      == 0 == false   // Also a set of 3 equal values, note that only 0 and false are repeated
'\t'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\r'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\n'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
'\t\r\n' == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

null == undefined  // These two "default" values are not-equal to any of the listed values above
NaN                // NaN is not equal to any thing, even to itself.

Respondido 19 Feb 14, 19:02

Es poco probable que haya alguna diferencia de rendimiento entre las dos operaciones en su uso. No se debe realizar ninguna conversión de tipo porque ambos parámetros ya son del mismo tipo. Ambas operaciones tendrán una comparación de tipos seguida de una comparación de valores.

Respondido el 11 de diciembre de 08 a las 17:12

¡Sí! Si importa.

=== operador en javascript comprueba el valor y el tipo mientras que == el operador solo verifica el valor (escribe conversión si es necesario).

enter image description here

Puedes probarlo fácilmente. Pegue el siguiente código en un archivo HTML y ábralo en el navegador

<script>

function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};

</script>

</head>

<body onload='onPageLoad();'>

Conseguirás 'false'en alerta. Ahora modifique el onPageLoad() método para alert(x == 5); conseguirás verdadero.

Respondido el 10 de enero de 15 a las 17:01

=== El operador comprueba la igualdad de los valores y los tipos de variables.

== El operador simplemente comprueba la igualdad del valor de las variables.

respondido 20 nov., 17:15

Es una prueba de control estricta.

Es algo bueno, especialmente si está marcando entre 0 y falso y nulo.

Por ejemplo, si tienes:

$a = 0;

Entonces:

$a==0; 
$a==NULL;
$a==false;

Todo devuelve verdadero y es posible que no desee esto. Supongamos que tiene una función que puede devolver el índice 0 de una matriz o falso en caso de falla. Si marca con "==" falso, puede obtener un resultado confuso.

Entonces, con lo mismo que el anterior, pero una prueba estricta:

$a = 0;

$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false

Respondido 27 Abr '15, 11:04

En JavaScript, esto es completamente incorrecto e incompleto. 0 != null. -1 - Ry- ♦

JSLint a veces te da razones poco realistas para modificar cosas. === tiene exactamente el mismo rendimiento que == si los tipos ya son los mismos.

Es más rápido solo cuando los tipos no son los mismos, en cuyo caso no intenta convertir tipos, sino que devuelve directamente un falso.

¿Entonces EN MI HUMILDE OPINIÓN, JSLint puede usarse para escribir código nuevo, pero debe evitarse a toda costa una optimización excesiva inútil.

Es decir, no hay razón para cambiar == a === en un cheque como if (a == 'test') cuando sepa con certeza que a solo puede ser una cadena.

Modificar una gran cantidad de código de esa manera desperdicia el tiempo de los desarrolladores y revisores y no logra nada.

respondido 20 nov., 17:15

simplemente

== significa comparación entre operandos con type conversion

&

=== significa comparación entre operandos sin type conversion

La conversión de tipos en javaScript significa que javaScript convierte automáticamente cualquier otro tipo de datos en tipos de datos de cadena.

Por ejemplo:

123=='123'   //will return true, because JS convert integer 123 to string '123'
             //as we used '==' operator 

123==='123' //will return false, because JS do not convert integer 123 to string 
            //'123' as we used '===' operator 

respondido 20 nov., 17:15

Un ejemplo simple es

2 == '2'  -> true, values are SAME because of type conversion.

2 === '2'  -> false, values are NOT SAME because of no type conversion.

Respondido 04 Jul 15, 06:07

Como regla general, generalmente usaría === en lugar de == (y !== en lugar de !=).

Las razones se explican en las respuestas anteriores y también Douglas Crockford es bastante claro al respecto (JavaScript: las partes buenas).

Sin embargo hay una sola excepción: == null es una forma eficiente de verificar si 'es nulo o indefinido':

if( value == null ){
    // value is either null or undefined
}

Por ejemplo, jQuery 1.9.1 usa este patrón 43 veces, y el Comprobador de sintaxis JSHint incluso proporciona el eqnull Opción relajante por este motivo.

Desde el guía de estilo de jQuery:

Deben usarse controles estrictos de igualdad (===) a favor de ==. La única excepción es cuando se comprueba si hay indefinido y nulo mediante nulo.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

Respondido 27 Abr '13, 18:04

Las 2 respuestas principales, ambas mencionadas, == significa igualdad y === significa identidad. Desafortunadamente, esta afirmación es incorrecta.

Si ambos operandos de == son objetos, entonces se comparan para ver si son el mismo objeto. Si ambos operandos apuntan al mismo objeto, el operador igual devuelve verdadero. De lo contrario, los dos no son iguales.

var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.log(a == b)  // false  
console.log(a === b) // false  

En el código anterior, tanto == como === se vuelven falsos porque ayb no son los mismos objetos.

Es decir: si ambos operandos de == son objetos, == se comporta igual que ===, que también significa identidad. La diferencia esencial de estos dos operadores es la conversión de tipos. == tiene conversión antes de verificar la igualdad, pero === no.

Respondido el 09 de Septiembre de 13 a las 12:09

El problema es que podría meterse en problemas fácilmente ya que JavaScript tiene muchas conversiones implícitas, lo que significa ...

var x = 0;
var isTrue = x == null;
var isFalse = x === null;

Lo que muy pronto se convierte en un problema. La mejor muestra de por qué la conversión implícita es "maligna" se puede tomar de este código en MFC / C ++ que en realidad se compilará debido a una conversión implícita de CString a HANDLE, que es un tipo de puntero typedef ...

CString x;
delete x;

Que obviamente durante el tiempo de ejecución cosas indefinidas ...

Google para conversiones implícitas en C ++ y STL para obtener algunos de los argumentos en contra ...

Respondido 26 Oct 14, 14:10

0 == null Es falso. - Garrett

Desde el referencia principal de javascript

=== Devoluciones true si los operandos son estrictamente iguales (ver arriba) sin conversión de tipo.

respondido 12 nov., 15:06

Comparación de igualdad:

Operador ==

Devuelve verdadero cuando ambos operandos son iguales. Los operandos se convierten al mismo tipo antes de compararlos.

>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true

Comparación de igualdad y tipo:

Operador ===

Devuelve verdadero si ambos operandos son iguales y del mismo tipo. En general, es mejor y más seguro si se compara de esta manera, porque no hay conversiones de tipo detrás de escena.

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

Respondido 03 Oct 13, 01:10

Aquí hay una práctica tabla de comparación que muestra las conversiones que ocurren y las diferencias entre == y ===.

Como dice la conclusión:

"Utilice tres iguales a menos que comprenda completamente las conversiones que tienen lugar para dos iguales".

http://dorey.github.io/JavaScript-Equality-Table/

respondido 27 mar '14, 15:03

nulo e indefinido son la nada, es decir,

var a;
var b = null;

Aquí a y b no tienen valores. Considerando que, 0, falso y '' son todos valores. Una cosa en común entre todos estos es que todos son valores falsos, lo que significa que todos satisfacer condiciones falsas.

Entonces, el 0, falso y '' juntos forman un subgrupo. Y por otro lado, nulos e indefinidos forman el segundo subgrupo. Verifique las comparaciones en la imagen de abajo. nulo e indefinido serían iguales. Los otros tres serían iguales entre sí. Pero todos se tratan como condiciones falsas en JavaScript.

Ingrese la descripción de la imagen aquí

Esto es lo mismo que cualquier objeto (como {}, matrices, etc.), una cadena no vacía y un booleano verdadero son todas condiciones verdaderas. Pero no todos son iguales.

Respondido 26 Oct 14, 14:10

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.