¿Cómo puedo determinar si una variable es 'indefinida' o 'nula'?

¿Cómo determino si la variable es undefinedo null?

Mi código es el siguiente:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  // DO SOMETHING
};

<div id="esd-names">
  <div id="name"></div>
</div>

Pero si hago esto, el intérprete de JavaScript detiene la ejecución.

Puede usar las cualidades del operador de igualdad abstracta para hacer esto:

if (variable == null){
    // your code here.
}

Porque null == undefinedes cierto, el código anterior capturará ambos nully undefined.

La forma estándar de atrapar nully undefinedsimultáneamente es esta:

if (variable == null) {
     // do something 
}

--que es 100% equivalente al más explícito pero menos conciso:

if (variable === undefined || variable === null) {
     // do something 
}

Al escribir JS profesional, se da por sentado que se entiende la igualdad de tipos y el comportamiento de ==vs. ===Por lo tanto, usamos ==y solo comparamos con null.

Editar de nuevo

Los comentarios que sugieren el uso de typeofson simplemente incorrectos. Sí, mi solución anterior causará un error de referencia si la variable no existe. Ésto es una cosa buena. Este ReferenceError es deseable: lo ayudará a encontrar sus errores y corregirlos antes de enviar su código, al igual que los errores del compilador en otros idiomas. Use try/ catchsi está trabajando con entradas sobre las que no tiene control.

No debe tener ninguna referencia a variables no declaradas en su código.

Combinando las respuestas anteriores, parece que la respuesta más completa sería:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

Esto debería funcionar para cualquier variable que no esté declarada o declarada y explícitamente establecida como nula o indefinida. La expresión booleana debe evaluarse como falsa para cualquier variable declarada que tenga un valor real no nulo.

if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

if (typeof EmpName != 'undefined' && EmpName) {

se evaluará como verdadero si el valor no es:

• nulo

• indefinido

• Yaya

• cuerda vacía ("")

• 0 0

• falso

La attr()función jQuery devuelve una cadena en blanco o el valor real (y nunca nullo undefined). El único momento en que regresa undefinedes cuando su selector no devolvió ningún elemento.

Por lo tanto, es posible que desee probar con una cadena en blanco. Alternativamente, dado que las cadenas en blanco, nulas e indefinidas son falsas, puede hacer esto:

if (!EmpName) { //do something }

He venido a escribir mi propia función para esto. JavaScript es raro.

Es utilizable en literalmente cualquier cosa. (Tenga en cuenta que esto también verifica si la variable contiene valores utilizables . Pero dado que esta información generalmente también es necesaria, creo que vale la pena publicarla). Por favor considere dejar una nota.

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

Compatible con TypeScript.

Esta función debería hacer exactamente lo mismo que la empty()función de PHP (verRETURN VALUES )

Considera undefined, null, false, 0, 0.0, "0" {}, []como vacío.

"0.0", NaN, " ", trueSe considera que no está vacía.

Si la variable que desea verificar es global, haga

if (window.yourVarName) {
    // Your code here
}

Esta forma de verificar no arrojará un error incluso si la yourVarNamevariable no existe.

Ejemplo: quiero saber si mi navegador admite API de historial

if (window.history) {
    history.back();
}

Cómo funciona esto:

windowes un objeto que contiene todas las variables globales como sus propiedades, y en JavaScript es legal intentar acceder a una propiedad de objeto no existente. Si historyno existe, entonces window.historyregresa undefined. undefinedes falsey, por lo que el código en un if(undefined){}bloque no se ejecutará.

El más corto y fácil:

if(!EmpName ){
 // DO SOMETHING
}

esto evaluará verdadero si EmpName es:

• nulo
• indefinido
• Yaya
• vacío
• cuerda ("")
• 0 0
• falso

Probablemente la forma más corta de hacer esto es:

if(EmpName == null) { /* DO SOMETHING */ };

Aquí está la prueba:

function check(EmpName) {
  if(EmpName == null) { return true; };
  return false;
}

var log = (t,a) => console.log(`${t} -> ${check(a)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" 

Y aquí hay más detalles sobre ==(fuente aquí )

BONIFICACIÓN : por qué ===es más claro que ==(mira la respuesta agc )

Acabo de tener este problema, es decir, verificar si un objeto es nulo.
Simplemente uso esto:

if (object) {
    // Your code
}

Por ejemplo:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

Dado que está utilizando jQuery , puede determinar si una variable no está definida o si su valor es nulo mediante el uso de una sola función.

var s; // undefined
jQuery.isEmptyObject(s); // will return true;

s = null; // defined as null
jQuery.isEmptyObject(s); // will return true;

// usage
if(jQuery.isEmptyObject(s)){
    alert('Either variable: s is undefined or its value is null');
}else{
     alert('variable: s has value ' + s);
}

s = 'something'; // defined with some value
jQuery.isEmptyObject(s); // will return false;

El elemento de verificación jQuery no es nulo:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

En JavaScript, según mi conocimiento, podemos verificar una variable indefinida, nula o vacía como se muestra a continuación.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Verifique todas las condiciones:

if(variable === undefined || variable === null || variable === ''){
}

Simplemente puede usar lo siguiente (sé que hay formas más cortas de hacerlo, pero esto puede hacer que sea más fácil de observar visualmente, al menos para otros que miran el código).

if (x === null || x === undefined) {
 // Add your response code here, etc.
}

La forma más fácil de verificar es:

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

Con la solución a continuación:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

Puedo verificar lo siguiente:

• nulo
• indefinido
• Yaya
• vacío
• cuerda ("")
• 0 0
• falso

Para probar si una variable es nula o indefinida, uso el siguiente código.

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

Ejecuto esta prueba en la consola de Chrome. Usando (nulo 0) puede verificar indefinido:

var c;
undefined
if (c === void 0) alert();
// output =  undefined
var c = 1;
// output =  undefined
if (c === void 0) alert();
// output =   undefined
// check c value  c
// output =  1
if (c === void 0) alert();
// output =  undefined
c = undefined;
// output =  undefined
if (c === void 0) alert();
// output =   undefined

Miremos esto,

1.  

   let apple; // Only declare the variable as apple
   alert(apple); // undefined

   En lo anterior, la variable solo se declara como apple. En este caso, si llamamos método alert, se mostrará indefinido.

2.  

      let apple = null; /* Declare the variable as apple and initialized but the value is null */
      alert(apple); // null

En el segundo muestra nulo, porque la variable de apple valor es nula.

Por lo tanto, puede verificar si un valor es indefinido o nulo.

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

Mejor manera:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}

(null == undefined)  // true

(null === undefined) // false

Porque === verifica tanto el tipo como el valor. El tipo de ambos es diferente pero el valor es el mismo.

var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

La foo == nullverificación debe hacer el truco y resolver el caso "indefinido O nulo" de la manera más breve. (Sin considerar el caso "foo no se declara"). Pero las personas que están acostumbradas a tener 3 iguales (como la mejor práctica) podrían no aceptarlo. Solo mira eqeqeq o triple-igual en eslint y tslint ...

El enfoque explícito, cuando estamos verificando si una variable es undefinedo por nullseparado, debe aplicarse en este caso, y mi contribución al tema (¡27 respuestas no negativas por ahora!) Es utilizarla void 0como una forma breve y segura de realizar la verificación paraundefined .

El uso foo === undefinedno es seguro porque indefinido no es una palabra reservada y puede sombrearse ( MDN ). El uso de la typeof === 'undefined'verificación es seguro, pero si no nos vamos a preocupar por un caso no declarado, se puede usar el siguiente enfoque:

if (foo === void 0 || foo === null) { ... }

si crea una función para verificarlo:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

Llamar a typeof null devuelve un valor de "objeto", ya que el valor especial nulo se considera una referencia de objeto vacía. Safari a través de la versión 5 y Chrome a través de la versión 7 tienen una peculiaridad en la que llamar a typeof en una expresión regular devuelve "función", mientras que todos los demás navegadores devuelven "objeto".

var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

Solo puede usar el segundo: ya que verificará tanto la definición como la declaración

Todavía creo que la mejor / segura manera de probar estas dos condiciones es convertir el valor en una cadena:

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // Do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // Do something with your code
}

Puede verificar si el valor es indefinido o nulo simplemente usando typeof:

if(typeof value == 'undefined'){

if(x==null)Es una mala idea en JavaScript. Juzgue con "=="- puede causar una coerción de tipo inesperada, y CoffeeScript no puede leerlo, ¡ nunca use "==" o "! =" En el juicio de condición!

if(x)será mejor, pero tenga cuidado con 0 y "" . Será tratado como falso , no el método igual con "!= null"es verdadero .

Ver las mejores prácticas de JavaScript .