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

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

¿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:

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

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

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:

• La verdad, la igualdad y el JavaScript de Angus Croll
• La coacción JavaScript de Andrea Giammarchi desmitificada
• Preguntas frecuentes de comp.lang.javascript: Conversión de tipo JavaScript

¿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

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.

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

let x;      // undefined
let y=null; // null
let z=3;    // has value
// 'w'      // is undeclared

if(!x) console.log('x is null or undefined');
if(!y) console.log('y is null or undefined');
if(!z) console.log('z is null or undefined');

try { if(w) 0 } catch(e) { console.log('w is undeclared') }
// typeof not throw exception for undelared variabels
if(typeof w === 'undefined') console.log('w is undefined');

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

== (su negación ! = )

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

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

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);
}

}