validar - variable undefined javascript




¿Existe una función estándar para verificar las variables nulas, indefinidas o en blanco en JavaScript? (20)

Aunque antiguo, lo que se olvida es que deben envolver su bloque de código y luego detectar el error y luego probar ...

function checkup( t ){
  try{
    for(p in t){
      if( p.hasOwnProperty( t ) ){
        return true;
      }
    }
    return false;
  }catch(e){
    console.log("ERROR : "+e);
    return e;
  }
}

Entonces, realmente no tiene que buscar un problema potencial de antemano, simplemente lo atrapa y luego lo resuelve de la manera que desee.

¿Existe una función de JavaScript universal que verifique que una variable tenga un valor y garantice que no esté undefined o null ? Tengo este código, pero no estoy seguro si cubre todos los casos:

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}

Creo que usando el? El operador es un poco más limpio.

var ? function_if_exists() : function_if_doesnt_exist();

Estás un poco exagerado. Para verificar si a una variable no se le asigna un valor, solo deberá verificar contra indefinido y nulo.

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}

Esto se supone que 0 , "" y los objetos (incluso el objeto vacío y la matriz) son valores válidos.


Esta condición comprueba

if (!!foo) {
    //foo is defined
}

es todo lo que necesitas.


Este es muy simple.

if(data) {
  //Comes inside only if the data is not empty and not null 
}

Esto verificará si la variable de anidación indeterminada no está definida

function Undef(str) 
{
  var ary = str.split('.');
  var w = window;
  for (i in ary) {
    try      { if (typeof(w = w[ary[i]]) === "undefined") return true; }
    catch(e) { return true; }
  }
  return false;
}

if (!Undef("google.translate.TranslateElement")) {

Lo anterior verifica si la función de traducción de Google TranslateElement existe. Esto es equivalente a:

if (!(typeof google === "undefined" 
 || typeof google.translate === "undefined" 
 || typeof google.translate.TranslateElement === "undefined")) {

La primera respuesta con la mejor calificación es incorrecta. Si el valor no está definido, lanzará una excepción en los navegadores modernos. Tienes que usar:

if (typeof(value) !== "undefined" && value)

o

if (typeof value  !== "undefined" && value)

Para mi caso probé con null, '',! Variable, pero no funcionó.

Vea mi código a continuación para obtener el texto de un campo html

var status=$(this).text(); //for example (for my case)

si no había ningún valor (sin texto) en la variable de estado, intentaba establecer el valor 'novalue' en la variable de estado.

El siguiente código funcionó.

if(status == false)
{
   status='novalue';
} 

cuando no se encontró texto para la variable satus, el código anterior asignó 'novalue' a la variable de estado


Puede encontrar útil la siguiente función:

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

O en ES7 (comentar si hay nuevas mejoras)

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);

  return type.toLowerCase();
}

Resultados:

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

"Tenga en cuenta que el operador de enlace (: :) no es parte de ES2016 (ES7) ni de ninguna edición posterior del estándar ECMAScript. Es actualmente una propuesta de etapa 0 (paja) para ser introducida al idioma". - Simon Kjellberg. El autor desea agregar su apoyo a esta hermosa propuesta para recibir la ascensión real.


Puede ser útil.

[null, undefined, ''].indexOf(document.DocumentNumberLabel) > -1

Puedes utilizar directamente el operador de igualdad.

<script>
    var firstName;
    var lastName = null;
    /* Since null == undefined is true, the following statements will catch both null and undefined */
        if(firstName == null){
            alert('Variable "firstName" is undefined.');
        }    
        if(lastName == null){
           alert('Variable "lastName" is null.');
        }
</script>

demo @ Cómo determinar si la variable no está definida o es nula usando JavaScript


Sé que esta es una pregunta antigua, pero esta es la verificación más segura y no la he visto publicada aquí exactamente así:

if (typeof value != 'undefined' && value) {
    //deal with value'
};

Cubrirá los casos donde el valor nunca se definió, y también cualquiera de estos:

  • nulo
  • indefinido (el valor de indefinido no es lo mismo que un parámetro que nunca se definió)
  • 0
  • "" (cuerda vacía)
  • falso
  • Yaya

¡PS no necesita una igualdad estricta en el valor de typeof! = 'Indefinido'


Si no se ha declarado la variable, no podrá probar la indefinición utilizando una función porque obtendrá un error.

if (foo) {}
function (bar) {}(foo)

Ambos generarán un error si no se ha declarado foo.

Si desea probar si una variable ha sido declarada puede usar

typeof foo != "undefined"

si desea probar si foo ha sido declarado y tiene un valor que puede usar

if (typeof foo != "undefined" && foo) {
    //code here
}

Si prefieres javascript plano prueba esto:

  /**
   * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
   * length of `0` and objects with no own enumerable properties are considered
   * "empty".
   *
   * @static
   * @memberOf _
   * @category Objects
   * @param {Array|Object|string} value The value to inspect.
   * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
   * @example
   *
   * _.isEmpty([1, 2, 3]);
   * // => false
   *
   * _.isEmpty([]);
   * // => true
   *
   * _.isEmpty({});
   * // => true
   *
   * _.isEmpty('');
   * // => true
   */

function isEmpty(value) {
    if (!value) {
      return true;
    }
    if (isArray(value) || isString(value)) {
      return !value.length;
    }
    for (var key in value) {
      if (hasOwnProperty.call(value, key)) {
        return false;
      }
    }
    return true;
  }

De lo contrario, si ya está usando guión bajo o lodash, intente:

_.isEmpty(value)

puedes usar:

Si cláusula para validar si la cadena o el valor no está vacío. Me gusta esto:

if (someVar.value) 
{
  //its not emppty
}
else
{
  //Its empty
}

Para comprobar el valor predeterminado

function typeOfVar (obj) {
      return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}
function isVariableHaveDefaltVal(variable) {
    if ( typeof(variable) === 'string' ) {  // number, boolean, string, object 
        console.log(' Any data Between single/double Quotes is treated as String ');        
        return (variable.trim().length === 0) ? true : false;
    }else if ( typeof(variable) === 'boolean' ) {
      console.log('boolean value with default value \'false\'');
        return (variable === false) ? true : false;
    }else if ( typeof(variable) === 'undefined' ) {
        console.log('EX: var a; variable is created, but has the default value of undefined.'); 
        return true;
    }else if ( typeof(variable) === 'number' ) { 
        console.log('number : '+variable);
        return (variable === 0 ) ? true : false;
    }else if ( typeof(variable) === 'object' ) {
   //   -----Object-----
        if (typeOfVar(variable) === 'array' && variable.length === 0) {
            console.log('\t Object Array with length = ' + [].length); // Object.keys(variable)
            return true;
        }else if (typeOfVar(variable) === 'string' && variable.length === 0 ) {
            console.log('\t Object String with length = ' + variable.length);
            return true;
        }else if (typeOfVar(variable) === 'boolean' ) {
            console.log('\t Object Boolean = ' + variable);
            return (variable === false) ? true : false;
        }else if (typeOfVar(variable) === 'number' ) {
            console.log('\t Object Number = ' + variable);
            return (variable === 0 ) ? true : false;
        }else if (typeOfVar(variable) === 'regexp' && variable.source.trim().length === 0 ) {
       console.log('\t Object Regular Expression : ');
        return true;
        }else if (variable === null) {
       console.log('\t Object null value');
        return true;
        }
    }
    return false;
}
var str = "A Basket For Every Occasion";
str = str.replace(/\s/g, "-");
//The "g" flag in the regex will cause all spaces to get replaced.

comprobar resultado:

isVariableHaveDefaltVal(' '); // string          
isVariableHaveDefaltVal(false); // boolean       
var a;           
isVariableHaveDefaltVal(a);               
isVariableHaveDefaltVal(0); // number             
isVariableHaveDefaltVal(parseInt('')); // NAN isNAN(' '); - true         
isVariableHaveDefaltVal(null);              
isVariableHaveDefaltVal([]);               
isVariableHaveDefaltVal(/ /);              
isVariableHaveDefaltVal(new Object(''));               
isVariableHaveDefaltVal(new Object(false));            
isVariableHaveDefaltVal(new Object(0)); 
typeOfVar( function() {} );

Utilicé la función @Vix () para verificar el objeto de qué tipo.

usando instansof «

var prototypes_or_Literals = function (obj) {
    switch (typeof(obj)) {
        // object prototypes
        case 'object':
            if (obj instanceof Array)
                return '[object Array]';
            else if (obj instanceof Date)
                return '[object Date]';
            else if (obj instanceof RegExp)
                return '[object regexp]';
            else if (obj instanceof String)
                return '[object String]';
            else if (obj instanceof Number)
                return '[object Number]';

            else
                return 'object';
        // object literals
        default:
            return typeof(obj);
    }   
};
output test «
prototypes_or_Literals( '' ) // "string"
prototypes_or_Literals( new String('') ) // "[object String]"
Object.prototype.toString.call("foo bar") //"[object String]"        

function isEmpty(obj) {
    if (typeof obj == 'number') return false;
    else if (typeof obj == 'string') return obj.length == 0;
    else if (Array.isArray(obj)) return obj.length == 0;
    else if (typeof obj == 'object') return obj == null || Object.keys(obj).length == 0;
    else if (typeof obj == 'boolean') return false;
    else return !obj;
}

En ES6 con corte para manejar cadenas de espacio en blanco:

const isEmpty = value => {
    if (typeof value === 'number') return false
    else if (typeof value === 'string') return value.trim().length === 0
    else if (Array.isArray(value)) return value.length === 0
    else if (typeof value === 'object') return value == null || Object.keys(value).length === 0
    else if (typeof value === 'boolean') return false
    else return !value
}

function isEmpty(val){
    return !val;
}

pero esta solución está sobre-diseñada, si no desea modificar la función más adelante para las necesidades del modelo de negocio, entonces es más limpio usarla directamente en el código:

if(!val)...

try{

     let vari = obj.propTest; // obj may be don't have propTest property

        ...
} catch(NullException){
    // do something here
}

Creo que usar try catch evitará cualquier error de comprobación nula, también en Angular o JavaScript. Solo detectará una excepción nula y procesará.


var myNewValue = myObject && myObject.child && myObject.child.myValue;

Esto nunca arrojará un error. Si myObject , child o myValue es nulo, myNewValue será nulo. No se lanzarán errores.





undefined