javascript - validar - ¿Cómo determinar si la variable es ''indefinida'' o ''nula''?

variable null javascript

Question

¿Cómo puedo determinar si la variable es undefined o 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.

Answer 1

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

if (object) { Somecode}

es decir

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

Answer 2

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 en nula o indefinida. La expresión booleana debe evaluar a falso para cualquier variable declarada que tenga un valor real no nulo.

Answer 3

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...

Soy capaz de verificar lo siguiente:

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

Answer 4

Dado que está utilizando jQuery , puede determinar si una variable no está definida o si su valor es nulo utilizando 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;

Answer 5

Ejecuto esta prueba en la consola de Chrome, usando (void 0) puedes 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

Answer 6

En algunas circunstancias es posible cambiar el valor de undefined . Si bien estos son generalmente raros, a veces puede ser mejor evitar el uso real del valor undefined .

Como resultado, y debido a que es más rápido de escribir, me he acostumbrado a usar un acceso directo para undefined que es mirar el primer valor de una matriz vacía. Se garantiza que este valor es el valor primitivo undefined , y se puede acceder con [][0] .

Esta comprobación funcionará para buscar tanto undefined como null .

Aquí hay un ejemplo:

(function(undefined){
    var foo = { baz: null };
    console.log(foo.bar === undefined); //false
    console.log(foo.bar == [][0]); //true
    console.log(foo.baz == [][0]); //true
}(50))

Answer 7

Esta es una pregunta muy antigua, pero sigo pensando que la mejor forma de probar estas 2 condiciones es convertir el valor en 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
}

Answer 8

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

Utilizable en cualquier cosa, literalmente. (Tenga en cuenta que esto también comprueba si la variable contiene valores utilizables. Pero como esta información también suele ser 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 mecanografía.

editar. esta función debe hacer exactamente lo mismo que la función empty() PHP (consulte RETURN VALUES )

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

"0.0" , NaN , " " , true se consideran no vacíos.

Answer 9

La forma estándar de capturar null e undefined simultáneamente es esta:

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

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

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

Cuando se escribe 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 typeof son 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.

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

Answer 10

La función jQuery attr() devuelve una cadena en blanco o el valor real (y nunca null o undefined ). La única vez que se devuelve undefined es cuando su selector no devolvió ningún elemento.

Así que es posible que desee probar contra una cadena en blanco. Alternativamente, como las cadenas en blanco, nulas e indefinidas son falsas, puedes hacer esto:

if (!EmpName) { //do something }

Answer 11

La llamada a typeof null devuelve un valor de "objeto", ya que el valor especial null 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 que llamar a typeof en una expresión regular devuelve "función", mientras que todos los demás navegadores devuelven "objeto".

Answer 12

Mejor manera:

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

/* do your stuff */
}

Answer 13

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

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

Answer 14

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

if(typeof value == ''undefined''){

Answer 15

Puedes comprobarlo por este método.

if([''object'',''undefined''].indexOf(typeof(variable)) != -1){
    console.log("variable is null or undefined.");
}

Answer 16

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

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

Debido a que null == undefined es verdadero, el código anterior detectará tanto null como undefined .

Answer 17

Si la variable que desea verificar es global, haga

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

Esta forma de verificar no generará un error incluso si la variable yourVarName no existe.

Ejemplo: quiero saber si mi navegador es compatible con la API de historial

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

Cómo funciona esto:

window es 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 el history no existe, entonces window.history devuelve undefined . undefined es falsey, por lo que el código en un bloque if(undefined){} no se ejecutará.

Answer 18

Veo que la publicación original estaba usando JQuery. Así que estoy agregando lo que he usado en el pasado a través de JQuery. Por lo general, cuando realizo una verificación de este tipo, no necesariamente estoy comprobando que el valor sea nulo o no definido solo para ese propósito. Más como "Es el valor allí, así que puedo realizar acciones en él". Así que para eso uso lo siguiente. No he probado todos los tipos, pero sé que funciona tanto para nulos como para no definidos. Además, los objetos y las matrices (la versión vacía de ellos devolverá verdadero). Además, por supuesto, si la variable no existe, obtendrás una excepción, pero honestamente trato de evitar eso a toda costa. Así que estoy de acuerdo con Aerovistae. Quiero saber sobre esto en mi código y no quiero saltearlo.

if ($.trim(value) != '''') {
   //Do Something
}

Answer 19

elemento de comprobación jQuery no nulo

var dvElement = $(''#dvElement'');

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

Answer 20

if(x==null) es una mala idea en javascript, juzgar con "==" puede causar una coacción inesperada y no puede leerse con coffee-script, nunca use "==" o "! =" para juzgar !

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

https://www.w3schools.com/js/js_best_practices.asp

Answer 21

(null == undefined)  // true

(null === undefined) // false

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

Answer 22

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

se evaluará como verdadero si el valor no es:

• nulo

• indefinido

• Yaya

• cuerda vacía ("")

• 0

• falso

Answer 23

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

Answer 24

var i;

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

Answer 25

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