Comprobación de JavaScript para nulos frente a indefinidos y diferencia entre == y ===

Resuelto MUG4N asked hace 13 años • 9 respuestas

  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 "===")?

MUG4N avatar Feb 24 '11 15:02 MUG4N
Aceptado

¿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 alo es undefined.

Lo es undefined:

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

...pero nuevamente, tenga en cuenta que el último es vago; también será cierto si alo es null.

Ahora, a pesar de lo anterior, la forma habitual de comprobarlos es utilizar 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 nully undefined?

Ambos son valores que se suelen utilizar para indicar la ausencia de algo. undefinedes el más genérico, usado como 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 le pregunta a un objeto. por una propiedad que no tiene. Pero también se puede utilizar explícitamente en todas esas situaciones. (Existe una diferencia entre un objeto que no tiene una propiedad y que tiene 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 fuera por completo).

nulles un poco más específico que undefined: Es una referencia de objeto en blanco. JavaScript está escrito de forma flexible, por supuesto, pero no todas las cosas con las que interactúa JavaScript están escritas de forma flexible. Si una API como el DOM en los navegadores necesita una referencia de objeto que esté en blanco, usamos null, no undefined. Y de manera similar, la operación del DOM getElementByIddevuelve una referencia de objeto, ya sea válida (si encontró el elemento DOM) o null(si no lo encontró).

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 ==utilizarán coerción de tipo para intentar que los valores coincidan, y ===no lo harán. Entonces, por ejemplo "1" == 1, es cierto, porque "1"obliga a 1. Pero "1" === 1es falso porque los tipos no coinciden. ( "1" !== 1es cierto.) El primer paso (real) ===es "¿Son los mismos tipos de operandos?" y si la respuesta es "no", el resultado es false. Si los tipos son los mismos, 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:

  • Comparación de igualdad abstracta ( ==, también llamada igualdad "flexible")
  • Comparación estricta de igualdad ( ===)
T.J. Crowder avatar Feb 24 '2011 08:02 T.J. Crowder

La diferencia es sutil.

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

Pero si luego lo asigna, a = null;ahora aserá null. En JavaScript nulles un objeto (pruebe 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 funciones. Es posible que desee tener un valor predeterminado, pero considere que nulo es aceptable. En cuyo caso podrá 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 lo pasa, doSomething(1, 2, null)entonces opcional será null.

En cuanto a los comparadores igual ==y estrictamente igual ===, el primero es de tipo débil, mientras que estrictamente igual también verifica el tipo de valores. Eso significa que 0 == "0"volverá a ser 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 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
Julien Portalier avatar Oct 02 '2012 12:10 Julien Portalier

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:

    • compruebe si es nullpor comparación directa usando ===. Ejemplo:x === null
    • compruebe si es undefinedmediante cualquiera de dos métodos básicos: comparación directa con undefinedo typeof. Por varias razones , prefiero typeof x === "undefined".
    • verifique si es una de nulllas undefinedreglas ==de coerción de tipo ligeramente arcano que significa que x == nullhace exactamente lo que desea y usa y confía en ellas.

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

Más lectura:

  • La verdad, la igualdad y JavaScript de Angus Croll
  • La coerción de JavaScript de Andrea Giammarchi desmitificada
  • Preguntas frecuentes sobre comp.lang.javascript: conversión de tipos de JavaScript
Tim Down avatar Oct 04 '2012 09:10 Tim Down

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

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

if(variable)

devolverá verdadero si la variable no contiene:

  • nulo
  • indefinido
  • 0
  • FALSO
  • "" (una cadena vacía)
  • Yaya
Sumit Joshi avatar Aug 04 '2017 13:08 Sumit Joshi