variable - undefined javascript error

JavaScript: ¿Cuál es la diferencia entre `if(! X)` y `if(x== null)`?

Question

¿Cuál es la diferencia entre if (!x) y if (x == null) ; es decir, ¿cuándo pueden ser diferentes sus resultados?

Answer 1

Digamos que x es una cadena.

x = undefined;
if(!x) {
alert("X is not a truthy value");
}
if(x == null) {
alert("X is null");
}
x = "";
if(!x) {
alert("X is not a truthy value");
}
if(x == null) {
alert("X is null");
}
x = null;
if(!x) {
alert("X is not a truthy value");
}
if(x == null) {
alert("X is null");
}

Notará que "X no es un valor verdadero" se muestra en los tres casos, pero solo en el caso de que X sea indefinido o nulo se muestre "X es nulo".

Cuando X es un valor booleano, (!x) será verdadero cuando X sea falso pero (x == null) no lo será. Para los números 0 y NaN se consideran valores falsos, por lo que no X es veraz.

Véalo en acción , incluida la diferencia entre == (igualdad mediante la conversión de tipos) y === (igualdad estricta)

Answer 2

Esta pregunta / respuesta tiene algunas funciones isTrue isFalse que pueden ayudar a la gente:

perdonar es verdad es falso

Answer 3

Los resultados pueden ser diferentes si x es falso, NaN, '''' (cadena vacía), indefinido (usando el operador de comparación estricto ===), o 0 (cero).

Vea la respuesta de Felix Kling para un excelente resumen de la comparación de tipos.

Answer 4

!x comprueba un valor falso. Esto será cierto para cualquier valor que pueda propagarse a falso por cualquier razón. Esto será cierto para permutaciones de false , 0 , etc. etc.

x == null es diferente porque var x = 0 NO será nulo ... pero SERÁ falso.

Answer 5

!x devolverá true para cada valor "falso" (cadena vacía, 0 , null , false , undefined , NaN ), mientras que x == null solo devolverá true si x es null ( edición: o aparentemente undefined (ver más abajo)).

Probar con x = 0 , hay una diferencia.

Se puede decir que el operador NO ! convierte un valor en su equivalente booleano opuesto. Esto es diferente a la comparación real de dos valores.

Además, si compara valores con == , JavaScript realiza la conversión de tipos, lo que puede provocar un comportamiento inesperado (como undefined == null ). Es mejor usar siempre una comparación estricta === (el valor y el tipo deben ser iguales) y hacer uso de la conversión de tipo solo si realmente sabe lo que está haciendo.

Algo para leer:

• Conversión de tipos de datos
• Operadores de comparación
• Operadores logicos

Actualizar:

Para obtener más información sobre la comparación no estricta de null e undefined (o la comparación en general), vale la pena echar un vistazo a la specification . El algoritmo de comparación se define allí (la comparación es x == y ):

1. Si el Tipo ( x ) es el mismo que el Tipo ( y ), entonces
   (...)
2. Si x es nulo e y no está definido , devuelva verdadero .
3. Si x no está definido y y es nulo , devuelva verdadero .
4. (...)

(...)

Answer 6

if (!x) 

coerces x usa la función interna de ToBoolean

if (x==null)

obliga a ambos operandos utilizando la función interna ToPrimitive (que generalmente resuelve cada lado en un número, ocasionalmente una cadena, dependiendo de los operandos)

Para una explicación completa de ToBoolean vs ToPrimitive, consulte http://javascriptweblog.wordpress.com/2011/02/07/truth-equality-and-javascript/