Comprobación de JavaScript para nulo vs. indefinido y diferencia entre == y ===


579
  1. ¿Cómo verifico una variable si es nullo undefinedy cuál es la diferencia entre nully undefined?

  2. ¿Cuál es la diferencia entre ==y ===(es difícil buscar en Google "===")?


10
2. La diferencia entre ==y ===está bien descrita aquí .
Uzbekjon

1. Use === En lugar de == JavaScript utiliza dos tipos diferentes de operadores de igualdad: === | ! == y == | ! = Se considera la mejor práctica utilizar siempre el conjunto anterior al comparar. "Si dos operandos son del mismo tipo y valor, entonces === produce verdadero y! == produce falso". - JavaScript: lo bueno Sin embargo, cuando trabaje con == y! =, Se encontrará con problemas al trabajar con diferentes tipos. En estos casos, intentarán coaccionar los valores, sin éxito. code.tutsplus.com/tutorials/…
jasonleonhard

44
Puede buscar en Google: "operador de igualdad estricta" - que obtiene resultados muy relevantes
Danield

Solo para agregar a las muchas respuestas aquí que puede usar la función lodash.com/docs#isNil para verificar si la variable es nula o indefinida
Kfir Erez

Respuestas:


936

¿Cómo verifico una variable si es nullo undefined...

Es la variable null:

if (a === null)
// or
if (a == null) // but see note below

... pero tenga en cuenta que esto último también será cierto si aes así undefined.

Es undefined:

if (typeof a === "undefined")
// or
if (a === undefined)
// or
if (a == undefined) // but see note below

... pero de nuevo, tenga en cuenta que el último es vago; También será cierto si aes así null.

Ahora, a pesar de lo anterior, la forma habitual de verificarlos es usar el hecho de que son falsey :

if (!a) {
    // `a` is falsey, which includes `undefined` and `null`
    // (and `""`, and `0`, and `NaN`, and [of course] `false`)
}

Esto se define por ToBoolean en la especificación.

... y cuál es la diferencia entre nully undefined?

Ambos valores se usan generalmente para indicar la ausencia de algo. undefinedes el más genérico, se usa como el valor predeterminado de las variables hasta que se les asigna algún otro valor, como el valor de los argumentos de la función que no se proporcionaron cuando se llamó a la función, y como el valor que se obtiene cuando se solicita un objeto para una propiedad que no tiene. Pero también se puede usar explícitamente en todas esas situaciones. (Hay una diferencia entre un objeto que no tiene una propiedad y la propiedad con el valor undefined; hay una diferencia entre llamar a una función con el valor undefinedde un argumento y dejar ese argumento por completo).

nulles un poco más específico que undefined: es una referencia de objeto en blanco. JavaScript se escribe libremente, por supuesto, pero no todas las cosas con las que JavaScript interactúa se escriben libremente. Si una API como el DOM en los navegadores necesita una referencia de objeto que está en blanco, se utiliza null, no undefined. Y de manera similar, la getElementByIdoperación del DOM devuelve una referencia de objeto, ya sea válida (si encontró el elemento DOM) o null(si no lo hizo).

Curiosamente (o no), son sus propios tipos. Es decir, nulles el único valor en el tipo Nulo, y undefinedes el único valor en el tipo Indefinido.

¿Cuál es la diferencia entre "==" y "==="

La única diferencia entre ellos es que ==hará una coerción de tipo para intentar que los valores coincidan, y ===no lo hará. Entonces, por ejemplo, "1" == 1es cierto, porque "1"obliga a 1. Pero "1" === 1es falso , porque los tipos no coinciden. ( "1" !== 1es cierto). El primer paso (real) de ===es "¿Son iguales los tipos de operandos?" y si la respuesta es "no", el resultado es false. Si los tipos son iguales, hace exactamente lo que ==hace.

La coerción de tipos utiliza reglas bastante complejas y puede tener resultados sorprendentes (por ejemplo, "" == 0es cierto).

Más en la especificación:


122
Para destilar la respuesta de TJ, === significa que el valor Y el tipo son los mismos.
Slappy

13
@Slappy: :-) @ MUG4N: Sí, eso es correcto. if (a) { ... }significaría "si aes verdadero", donde "verdadero" es un valor de cadena no cero, no nulo, no indefinido, no falso, no vacío. :-)
TJ Crowder

44
Um ... ¿le gustaría al votante negativo compartir algunos comentarios útiles sobre por qué cree que esto "no fue útil" (para citar la información sobre herramientas del botón de voto negativo)?
TJ Crowder

2
@ Željko: Creo que Crockford puede estar equivocado en este punto. Es cierto que nullno es un objeto , es una referencia de objeto que significa "sin objeto". Esto es importante, porque es lo que se usa con las interfaces proporcionadas por el host cuando proporcionan referencias de objetos pero no tienen una para proporcionar (por ejemplo, node.nextSiblingcuándo nodees el último elemento en su elemento primario o getElementByIdcuando no hay ningún elemento con esa ID). La tecnología que utiliza el host para esto puede no ser tan flexible como JavaScript es sobre los tipos de variables / propiedades, por lo que era necesario tener una nullreferencia obj (en lugar de undefined).
TJ Crowder

2
Tengo que aceptar que Crockford está equivocado. typeof nulldevolver "objeto" tiene sentido. El único otro valor que tendría sentido sería "nulo", ya que definitivamente debería devolver algo diferente de typeof undefined. null representa una referencia de objeto nulo, que, como mínimo, significa que la variable que la contiene está destinada a algún tipo de 'objeto'. Si fue un error, fue un buen error. De todos modos, en lo que respecta a la respuesta, es bueno saber el consejo sobre undefined! == undefineddurante la secuencia de comandos de ventanas cruzadas, especialmente para fines de depuración.
Triynko

93

La diferencia es sutil.

En JavaScript, una undefinedvariable es una variable que nunca se ha declarado o que nunca se le ha asignado un valor. Digamos que declaras, var a;por ejemplo, alo será undefined, porque nunca se le asignó ningún valor.

Pero si después se asigna a = null;a continuación, aserá ahora null. En JavaScript nulles un objeto (intente typeof nullen una consola de JavaScript si no me cree), lo que significa que nulo es un valor (de hecho, incluso undefinedes un valor).

Ejemplo:

var a;
typeof a;     # => "undefined"

a = null;
typeof null;  # => "object"

Esto puede resultar útil en argumentos de función. Es posible que desee tener un valor predeterminado, pero considere nulo como aceptable. En cuyo caso puedes hacer:

function doSomething(first, second, optional) {
    if (typeof optional === "undefined") {
        optional = "three";
    }
    // do something
}

Si omite, el optionalparámetro doSomething(1, 2) thenopcional será la "three"cadena, pero si pasa, doSomething(1, 2, null)entonces será opcional null.

En cuanto a los comparadores iguales ==y estrictamente iguales ===, el primero es de tipo débil, mientras que estrictamente igual también verifica el tipo de valores. Eso significa que 0 == "0"volverá verdadero; while 0 === "0"devolverá falso, porque un número no es una cadena.

Puede utilizar esos operadores para verificar entre undefinedun null. Por ejemplo:

null === null            # => true
undefined === undefined  # => true
undefined === null       # => false
undefined == null        # => true

El último caso es interesante, porque le permite verificar si una variable es indefinida o nula y nada más:

function test(val) {
    return val == null;
}
test(null);       # => true
test(undefined);  # => true

1
Kyle Simpson afirma que el tipo de "objeto" que devuelve nulo es un error: github.com/getify/You-Dont-Know-JS/blob/master/…
bzrk

15

La especificación es el lugar para obtener respuestas completas a estas preguntas. Aquí hay un resumen:

  1. Para una variable x, puedes:

    • compruebe si es nullpor comparación directa usando ===. Ejemplo:x === null
    • compruebe si es undefinedpor cualquiera de los dos métodos básicos: comparación directa con undefinedo typeof. Por varias razones , prefiero typeof x === "undefined".
    • comprobar si se trata de uno de nully undefinedmediante el uso ==y confiando en las reglas de tipo de coerción poco arcanos que media x == nullhace exactamente lo que quiere.

  2. La diferencia básica entre ==y ===es que si los operandos son de diferentes tipos, ===siempre volverán falsemientras ==convertirá uno o ambos operandos en el mismo tipo utilizando reglas que conducen a un comportamiento poco intuitivo. Si los operandos son del mismo tipo (por ejemplo, ambos son cadenas, como en la typeofcomparación anterior), ==y ===se comportarán exactamente igual.

Más lectura:


9

¿Cómo verifico una variable si es nula o no está definida?

solo verifique si una variable tiene un valor válido como este:

if(variable)

devolverá verdadero si la variable no contiene:

  • nulo
  • indefinido
  • 0 0
  • falso
  • "" (una cadena vacía)
  • Yaya

8

indefinido

Significa que la variable aún no está inicializada.

Ejemplo:

var x;
if(x){ //you can check like this
   //code.
}

igual (==)

Solo verifica que el valor sea igual al tipo de datos no.

Ejemplo:

var x = true;
var y = new Boolean(true);
x == y ; //returns true

Porque solo verifica el valor.

Estrictos iguales (===)

Comprueba que el valor y el tipo de datos deben ser iguales.

Ejemplo:

var x = true;
var y = new Boolean(true);
x===y; //returns false.

Debido a que verifica que el tipo de datos x es un tipo primitivo e y es un objeto booleano.


4

El anuncio 1. nullno es un identificador para una propiedad del objeto global, como undefined puede ser

Anuncio 2. Los ===valores y tipos de verificación. El ==no requieren mismos tipos y conversión implícita hecha antes de la comparación (usando .valueOf()y .toString()). Aquí tienes todo ( src ):

Si

ingrese la descripción de la imagen aquí

== (su negación ! = )

ingrese la descripción de la imagen aquí

=== (su negación ! == )

ingrese la descripción de la imagen aquí


1
vale la pena mencionar eso document.all == nullydocument.all !== null
un usuario

1

Si su verificación (lógica) es para una negación (!) Y desea capturar JS nully undefined (ya que diferentes navegadores le darán resultados diferentes), usaría la comparación menos restrictiva: por ejemplo:

var ItemID = Item.get_id();
if (ItemID != null)
{
 //do stuff
}

Esto capturará ambos nullyundefined


0

Probar con lógica diferente . Puede usar el siguiente código para verificar las cuatro (4) condiciones para la validación como no nulo, no en blanco, no indefinido y no cero solo use este código (! (! (Variable))) en javascript y jquery.

function myFunction() {
var data;  //The Values can be like as null, blank, undefined, zero you can test

if(!(!(data)))
{
   //If data has valid value
    alert("data "+data);
} 
else 
{
    //If data has null, blank, undefined, zero etc.
    alert("data is "+data);
}

}

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.