Búsqueda de sitios web

Comprobación en JavaScript de null frente a undefined y diferencia entre == y ===

  1. ¿Cómo verifico una variable si es null o undefined y cuál es la diferencia entre null y undefined?

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

Respuesta #1

¿Cómo verifico si una variable es null o undefined...

¿La variable null:

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

...pero ten en cuenta que lo último también será cierto si a es undefined.

¿Está undefined:

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

...pero nuevamente, ten en cuenta que el último es ambiguo; también será cierto si a es null.

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

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

Esto está definido por ToBoolean en la especificación.

...¿y cuál es la diferencia entre null y undefined?

Ambos son valores que generalmente se utilizan para indicar la ausencia de algo. undefined es el más genérico, utilizado como el valor predeterminado de las variables hasta que se les asigna otro valor, como el valor de los argumentos de función que no se proporcionaron cuando se llamó la función, y como el valor que obtienes cuando consultas un objeto por una propiedad que no tiene. Pero también puede ser utilizado explícitamente en todas esas situaciones. (Hay una diferencia entre que un objeto no tenga una propiedad y que tenga la propiedad con el valor undefined; hay una diferencia entre llamar a una función con el valor undefined para un argumento y dejar ese argumento completamente fuera.)

null es un poco más específico que undefined: es una referencia de objeto vacía. JavaScript es débilmente tipado, por supuesto, pero no todas las cosas con las que JavaScript interactúa son débilmente tipadas. Si una API como el DOM en los navegadores necesita una referencia de objeto que esté vacía, usamos null, no undefined. Y de manera similar, la operación getElementById del DOM devuelve una referencia de objeto: ya sea una válida (si encontró el elemento del DOM), o null (si no lo encontró).

Curiosamente (o no), son sus propios tipos. Es decir, null es el único valor del tipo Null, y undefined es el único valor del tipo Undefined.

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

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

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

Más en la especificación:

  • Comparación de igualdad abstracta (==, también llamada igualdad "flexible")
  • Comparación de igualdad estricta (===)

Respuesta #2

La diferencia es sutil.

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

Pero si luego asignas a=null; entonces a ahora será null. En JavaScript null es un objeto (prueba typeof null en una consola de JavaScript si no me crees), lo que significa que null es un valor (de hecho, incluso undefined es un valor).

Ejemplo :

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

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

Esto puede resultar útil en los argumentos de las funciones. Es posible que desees tener un valor predeterminado, pero considera que null sea aceptable. En ese caso, puedes hacer:

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

Si omites el parámetro opcional doSomething(1, 2) entoncesopcional será la cadena "three", pero si pasas doSomething(1, 2, null) entonces opcional será null.

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

Puede usar esos operadores para verificar entre undefined y null. Por ejemplo:

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

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

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

Respuesta #3

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

  1. Para una variable x, puedes:

    • verificar si es null mediante comparación directa usando ===. Ejemplo: x === null
    • verifica si es undefined mediante cualquiera de dos métodos básicos: comparación directa con undefined o typeof. Por varias razones, prefiero typeof x === "undefined".
    • verificar si es uno de null y undefined usando == y confiando en las reglas de coerción de tipo un poco arcanas que significan que x == null hace exactamente lo que deseas.
  2. La diferencia básica entre == y === es que si los operandos son de tipos diferentes, === siempre devolverá false, mientras que == convertirá uno o ambos operandos al mismo tipo usando reglas que pueden conducir a un comportamiento un poco contraintuitivo. Si los operandos son del mismo tipo (por ejemplo, ambos son cadenas, como en la comparación de typeof mencionada arriba), == y === se comportarán exactamente igual.

Más lectura:

  • La verdad, la igualdad y JavaScript de Angus Croll
  • La coerción en JavaScript desmitificada por Andrea Giammarchi
  • comp.lang.javascript Preguntas frecuentes: Conversión de tipos en JavaScript

Respuesta #4

¿Cómo verifico si una variable es nula o indefinida?

solo verifica si una variable tiene un valor válido así:

if(variable)

devolverá verdadero si la variable no contiene :

  • nulo
  • indefinida
  • falsa
  • "" (una cadena vacía)
  • NaN

Artículos relacionados