validar - variable undefined javascript




¿Cómo determinar si la variable es 'indefinida' o 'nula'? (17)

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


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';

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.


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;

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

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
}

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.


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 }

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


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

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

if(typeof value == 'undefined'){

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 .


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


elemento de comprobación jQuery no nulo

var dvElement = $('#dvElement');

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

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


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

se evaluará como verdadero si el valor no es:

  • nulo

  • indefinido

  • Yaya

  • cuerda vacía ("")

  • 0

  • falso


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

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





undefined