validar - variable null javascript

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

Question

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

Answer 1

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.

Answer 2

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

var ? function_if_exists() : function_if_doesnt_exist();

Answer 3

El método detallado para verificar si el valor es indefinido o nulo es:

return value === undefined || value === null;

También puede usar el operador == pero esto espera que uno conozca todas las reglas :

return value == null; // also returns true if value is undefined

Answer 4

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.

Answer 5

Esta condición comprueba

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

es todo lo que necesitas.

Answer 6

Esta función comprueba si hay empty object {} , una empty array [] , null , undefined y una blank string ""

function isEmpty(val) {
  //check for empty object {}, array []
  if (val !== null && typeof val === ''object'') {
    if (Object.keys(obj).length === 0) {
      return true;
    }
  }
  //check for undefined, null and "" 
  else if (val == null || val === "") {
    return true;
  }
  return false;
}

var val = {};
isEmpty (val) -> verdadero
val = [];
isEmpty (val) -> verdadero
isEmpty (undefined) -> true
isEmpty (null) -> true
isEmpty ("") -> true
isEmpty (falso) -> falso
isEmpty (0) -> false

Answer 7

Este es muy simple.

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

Answer 8

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")) {

Answer 9

He aquí el mío: devuelve verdadero si el valor es nulo, indefinido, etc. o está en blanco (es decir, solo contiene espacios en blanco):

function stringIsEmpty(value) {

    return value ? value.trim().length == 0 : true;

}

Answer 10

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)

Answer 11

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

Answer 12

Para todos los que vienen aquí por preguntas similares, los siguientes trabajos son excelentes y los tengo en mi biblioteca los últimos años:

(function(g3, $, window, document, undefined){
   g3.utils = g3.utils || {};
/********************************Function type()********************************
* Returns a lowercase string representation of an object''s constructor.
* @module {g3.utils}
* @function {g3.utils.type}
* @public
* @param {Type} ''obj'' is any type native, host or custom.
* @return {String} Returns a lowercase string representing the object''s 
* constructor which is different from word ''object'' if they are not custom.
* @reference http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
* http://.com/questions/3215046/differentiating-between-arrays-and-hashes-in-javascript
* http://javascript.info/tutorial/type-detection
*******************************************************************************/
g3.utils.type = function (obj){
   if(obj === null)
      return ''null'';
   else if(typeof obj === ''undefined'')
      return ''undefined'';
   return Object.prototype.toString.call(obj).match(/^/[object/s(.*)/]$/)[1].toLowerCase();
};
}(window.g3 = window.g3 || {}, jQuery, window, document));

Answer 13

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.

Answer 14

Puede ser útil.

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

Answer 15

Puede usar el código de abajo 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)))
    {
        alert("data "+data);
    } 
    else 
    {
        alert("data is "+data);
    }
}

Answer 16

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

Answer 17

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

Answer 18

Si está utilizando TypeScript y no quiere tener en cuenta los "valores que son false " , esta es la solución para usted:

Primero: import { isNullOrUndefined } from ''util'';

Entonces: isNullOrUndefined(this.yourVariableName)

Tenga en cuenta: Como se menciona a below ahora está en desuso, use value === undefined || value === null value === undefined || value === null lugar. ref .

Answer 19

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
}

Answer 20

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)

Answer 21

Solo puedes verificar si la variable tiene un valor truthy o no. Eso significa

if( value ) {
}

se evaluará como true si el value no es:

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

La lista anterior representa todos los valores falsy posibles en ECMA- / Javascript. Encuéntralo en la specification en la sección de ToBoolean .

Además, si no sabe si existe una variable (es decir, si se declaró ), debe verificar con el operador typeof . Por ejemplo

if( typeof foo !== ''undefined'' ) {
    // foo could get resolved and it''s defined
}

Si puede estar seguro de que una variable se declara al menos, debe verificar directamente si tiene un valor truthy como el que se muestra arriba.

Más información: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

Answer 22

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
}

Answer 23

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

Answer 24

! compruebe si hay cadenas vacías (""), nulas, indefinidas, falsas y el número 0 y NaN. Digamos que si una cadena está vacía var name = "" entonces console.log(!name) devuelve true .

function isEmpty(val){
  return !val;
}

esta función devolverá verdadero si val está vacío, nulo, indefinido, falso, el número 0 o NaN .

Answer 25

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
}

Answer 26

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

Answer 27

function isEmpty(value){
  return (value == null || value.length === 0);
}

Esto volverá verdadero para

undefined  // Because undefined == null

null

[]

""

y las funciones de argumento cero ya que la length una función es el número de parámetros declarados que toma.

Para rechazar la última categoría, es posible que solo desee verificar si hay cadenas en blanco

function isEmpty(value){
  return (value == null || value === '''');
}

Answer 28

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

Answer 29

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.