¿Hay una función universal de JavaScript que comprueba que una variable tiene un valor y asegura que no es undefinedo 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;
}

Simplemente puede verificar si la variable tiene un truthyvalor o no. Eso significa

if( value ) {
}

evaluará truesi novalue es :

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

La lista anterior representa todos los falsyvalores posibles en ECMA- / Javascript. Encuéntrelo en la especificación en la ToBooleansección.

Además, si no sabe si existe una variable (es decir, si se declaró ), debe consultar con el typeofoperador. 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 truthyvalor como el que se muestra arriba.

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

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 se espera que uno conozca todas las reglas :

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

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

Esto volverá cierto para

undefined  // Because undefined == null

null

[]

""

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

Para no permitir la última categoría, es posible que solo desee verificar las cadenas en blanco

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

Este es el control más seguro y no lo he visto publicado aquí exactamente así:

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

Cubrirá casos en los que el valor nunca se definió, y también alguno de estos:

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

_{Editado: Cambiado a igualdad estricta (! ==) porque ya es la norma;)}

Puede encontrar útil la siguiente función:

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

O en ES7 (comenta si hay más 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 forma parte de ES2016 (ES7) ni de ninguna edición posterior del estándar ECMAScript. Actualmente es una propuesta de etapa 0 (strawman) para ser introducido en el lenguaje". - Simon Kjellberg. el autor desea agregar su apoyo a esta hermosa propuesta para recibir la ascensión real.

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

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

o

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

Esta comprobación de estado

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

es todo lo que necesitas.

! compruebe si hay cadenas vacías (""), nulas, indefinidas, falsas y el número 0 y NaN. Digamos, si una cadena está vacía, var name = ""entonces console.log(!name)regresa 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 .

O

De acuerdo con el dominio de su problema, puede usar like !valo !!val.

Una solución que me gusta mucho:

Definamos que una variable en blanco es null, o undefined, o si tiene longitud, es cero, o si es un objeto, no tiene claves:

function isEmpty (value) {
  return (
    // null or undefined
    (value == null) ||

    // has length and it's zero
    (value.hasOwnProperty('length') && value.length === 0) ||

    // is an Object and has no keys
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

Devoluciones:

• verdadera: undefined , null, "", [],{}
• falso: true , false, 1, 0, -1, "foo", [1, 2, 3],{ foo: 1 }

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

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

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

Si prefiere JavaScript simple, intente 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 subrayado o lodash, intente:

_.isEmpty(value)

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

function stringIsEmpty(value) {

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

}

return val || 'Handle empty variable'

es una forma muy agradable y limpia de manejarlo en muchos lugares, también se puede usar para asignar variables

const res = val || 'default value'

Si la variable no ha sido declarada, no podrá probar indefinido 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 se ha declarado una variable, puede usar

typeof foo != "undefined"

si quieres probar si foo ha sido declarado y tiene un valor que puedes usar

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

Para verificar 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() {} );

Usé 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 moldura para manejar cadenas de espacios 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
}

Puede ser útil

Todos los valores en la matriz representan lo que quieres ser (nulo, indefinido u otras cosas) y buscas lo que quieres en él.

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1

Si está utilizando TypeScripty no desea tener en cuenta los "valores que son false" entonces esta es la solución para usted:

Primero: import { isNullOrUndefined } from 'util';

Entonces: isNullOrUndefined(this.yourVariableName)

Tenga en cuenta: como se menciona a continuación, esto ahora está en desuso, use value === undefined || value === nullen su lugar. ref .

Vacío

No recomiendo tratar de definir o usar una función que calcule si algún valor en todo el mundo está vacío. ¿Qué significa realmente estar "vacío"? Si tengo let human = { name: 'bob', stomach: 'empty' }, debería isEmpty(human)volver true? Si tengo let reg = new RegExp('');, debería isEmpty(reg)volver true? ¿Qué pasa isEmpty([ null, null, null, null ])? Esta lista solo contiene el vacío, entonces, ¿está vacía la lista misma? Quiero presentar aquí algunas notas sobre "vacuidad" (una palabra intencionalmente oscura, para evitar asociaciones preexistentes) en javascript, y quiero argumentar que la "vacuidad" en los valores de javascript nunca debe tratarse genéricamente.

Verdad / falsedad

Para decidir cómo determinar la "vacuidad" de los valores, necesitamos acomodar el sentido inherente e inherente de JavaScript de si los valores son "verdaderos" o "falsos". Naturalmente, nully undefinedambos son "falsos". Menos naturalmente, el número 0(y ningún otro número excepto NaN) también es "falso". Menos natural: ''es falso, pero []y {}(y new Set(), y new Map()) son verdaderos, ¡aunque todos parecen igualmente vacíos!

Nulo vs Indefinido

También hay una discusión acerca de nullvs undefined: ¿realmente necesitamos ambos para expresar vacío en nuestros programas? Personalmente, evito que las letras u, n, d, e, f, i, n, e, d aparezcan en mi código en ese orden. Siempre uso nullpara significar "vacuidad". Una vez más, sin embargo, necesitamos acomodar el sentido inherente de JavaScript de cómo nully undefineddiferir:

• Intentar acceder a una propiedad inexistente da undefined
• Omitir un parámetro al llamar a una función da como resultado que ese parámetro reciba undefined:

let f = a => a;
console.log(f('hi'));
console.log(f());

• Los parámetros con valores predeterminados reciben el valor predeterminado solo cuando se proporcionan undefined, no null:

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

Vacío no genérico

Creo que la vacuidad nunca debe tratarse de manera genérica. En su lugar, siempre deberíamos tener el rigor de obtener más información sobre nuestros datos antes de determinar si son vacíos; principalmente hago esto verificando qué tipo de datos estoy tratando:

let isType = (value, Cls) => {
  try {
    return Object.getPrototypeOf(value).constructor === Cls;
  } catch(err) {
    return false;
  }
};

Tenga en cuenta que esta función ignora el polimorfismo: espera valueser una instancia directa de Cls, y no una instancia de una subclase de Cls. Evito instanceofpor dos razones principales:

• ([] instanceof Object) === true ("Una matriz es un objeto")
• ('' instanceof String) === false ("Una cadena no es una cadena")

Tenga en cuenta que Object.getPrototypeOfse utiliza para evitar un caso como let v = { constructor: String };La isTypefunción todavía regresa correctamente para isType(v, String)(falso) y isType(v, Object)(verdadero).

En general, recomiendo usar esta isTypefunción junto con estos consejos:

• Minimice la cantidad de valores de procesamiento de código de tipo desconocido. Por ejemplo, para let v = JSON.parse(someRawValue);, nuestra vvariable ahora es de tipo desconocido. Tan pronto como sea posible, debemos limitar nuestras posibilidades. La mejor manera de hacerlo puede ser exigiendo un tipo particular: por ejemplo if (!isType(v, Array)) throw new Error('Expected Array');, esta es una forma realmente rápida y expresiva de eliminar la naturaleza genérica de v, y garantizar que siempre sea así Array. A veces, sin embargo, debemos permitir vser de múltiples tipos. En esos casos, debemos crear bloques de código donde vya no sea genérico, lo antes posible:

if (isType(v, String)) {
  /* v isn't generic in this block - It's a String! */
} else if (isType(v, Number)) {
  /* v isn't generic in this block - It's a Number! */
} else if (isType(v, Array)) {
  /* v isn't generic in this block - it's an Array! */
} else {
  throw new Error('Expected String, Number, or Array');
}

• Utilice siempre "listas blancas" para la validación. Si necesita que un valor sea, por ejemplo, una cadena, un número o una matriz, verifique esas 3 posibilidades "blancas" y arroje un error si ninguno de los 3 está satisfecho. Deberíamos poder ver que verificar las posibilidades "negras" no es muy útil: digamos que escribimos if (v === null) throw new Error('Null value rejected');, esto es excelente para garantizar que los nullvalores no se logren, pero si un valor se logra , todavía no lo sabemos nada al respecto. Un valor vque pasa esta verificación nula sigue siendo MUY genérico, ¡es todo menosnull eso ! Las listas negras apenas disipan el genérico.

• A menos que un valor sea null, nunca considere "un valor vacío". En cambio, considere "una X que está vacía". Esencialmente, nunca considere hacer algo como if (isEmpty(val)) { /* ... */ }: no importa cómo isEmptyse implemente esa función (no quiero saber ...), ¡no tiene sentido! ¡Y es demasiado genérico! La vacuidad solo debe calcularse con conocimiento del valtipo. Los controles de vacío deberían tener este aspecto:

  • "Una cadena, sin caracteres": if (isType(val, String) && val.length === 0) ...
  • "Un objeto, con 0 accesorios": if (isType(val, Object) && Object.entries(val).length === 0) ...
  • "Un número, igual o menor que cero": if (isType(val, Number) && val <= 0) ...

  • "Una matriz, sin elementos": if (isType(val, Array) && val.length === 0) ...

  • La única excepción es cuando nullse usa para indicar cierta funcionalidad. En este caso es significativo decir: "Un valor vacío":if (val === null) ...

Probar con lógica diferente . Puede usar el siguiente código 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);
    }
}

Eche un vistazo al nuevo operador de fusión nula ECMAScript

Puede pensar en esta característica, el ??operador, como una forma de "retroceder" a un valor predeterminado cuando se trata con nullo undefined.

let x = foo ?? bar();

Nuevamente, el código anterior es equivalente al siguiente.

let x = (foo !== null && foo !== undefined) ? foo : bar();

function isEmpty(val){
    return !val;
}

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

if(!val)...

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 arrojarán errores

Para todos los que vienen aquí por tener una pregunta similar, lo siguiente funciona muy bien y lo 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://stackoverflow.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));

Si desea evitar ser verdadero si el valor es cualquiera de los siguientes, según la respuesta de jAndy :

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

Una posible solución que podría evitar obtener valores verdaderos es la siguiente:

function isUsable(valueToCheck) {
    if (valueToCheck === 0     || // Avoid returning false if the value is 0.
        valueToCheck === ''    || // Avoid returning false if the value is an empty string.
        valueToCheck === false || // Avoid returning false if the value is false.
        valueToCheck)             // Returns true if it isn't null, undefined, or NaN.
    {
        return true;
    } else {
        return false;
    }
}

Se usaría de la siguiente manera:

if (isUsable(x)) {
    // It is usable!
}
// Make sure to avoid placing the logical NOT operator before the parameter (isUsable(!x)) and instead, use it before the function, to check the returned value.
if (!isUsable(x)) {
    // It is NOT usable!
}

Además de esos escenarios, es posible que desee devolver falso si el objeto o la matriz están vacíos:

• Objeto: {} (usando ECMA 7+ )
• Matriz: [] (usando ECMA 5+ )

Lo harías de esta manera:

function isEmptyObject(valueToCheck) {
    if(typeof valueToCheck === 'object' && !Object.keys(valueToCheck).length){
        // Object is empty!
        return true;
    } else {
        // Object is not empty!
        return false;
    }
}

function isEmptyArray(valueToCheck) {
    if(Array.isArray(valueToCheck) && !valueToCheck.length) {
        // Array is empty!
        return true;
    } else {
        // Array is not empty!
        return false;
    }
}

Si desea verificar todas las cadenas de espacios en blanco (""), puede hacer lo siguiente:

function isAllWhitespace(){
    if (valueToCheck.match(/^ *$/) !== null) {
        // Is all whitespaces!
        return true;
    } else {
        // Is not all whitespaces!
        return false;
    }
}

Nota: hasOwnPropertydevuelve verdadero para cadenas vacías, 0, falso, NaN, nulo e indefinido, si la variable se declaró como cualquiera de ellos, por lo que podría no ser la mejor opción. La función puede modificarse para usarla para mostrar que se declaró, pero no es utilizable.

Código en GitHub

const isEmpty = value => (
  (!value && value !== 0 && value !== false)
  || (Array.isArray(value) && value.length === 0)
  || (isObject(value) && Object.keys(value).length === 0)
  || (typeof value.size === 'number' && value.size === 0)

  // `WeekMap.length` is supposed to exist!?
  || (typeof value.length === 'number'
      && typeof value !== 'function' && value.length === 0)
);

// Source: https://levelup.gitconnected.com/javascript-check-if-a-variable-is-an-object-and-nothing-else-not-an-array-a-set-etc-a3987ea08fd7
const isObject = value =>
  Object.prototype.toString.call(value) === '[object Object]';

Las pruebas del pobre hombre 😁

const test = () => {
  const run = (label, values, expected) => {
    const length = values.length;
    console.group(`${label} (${length} tests)`);
    values.map((v, i) => {
      console.assert(isEmpty(v) === expected, `${i}: ${v}`);
    });
    console.groupEnd();
  };

  const empty = [
    null, undefined, NaN, '', {}, [],
    new Set(), new Set([]), new Map(), new Map([]),
  ];
  const notEmpty = [
    ' ', 'a', 0, 1, -1, false, true, {a: 1}, [0],
    new Set([0]), new Map([['a', 1]]),
    new WeakMap().set({}, 1),
    new Date(), /a/, new RegExp(), () => {},
  ];
  const shouldBeEmpty = [
    {undefined: undefined}, new Map([[]]),
  ];

  run('EMPTY', empty, true);
  run('NOT EMPTY', notEmpty, false);
  run('SHOULD BE EMPTY', shouldBeEmpty, true);
};

Resultados de la prueba:

EMPTY (10 tests)
NOT EMPTY (16 tests)
SHOULD BE EMPTY (2 tests)
  Assertion failed: 0: [object Object]
  Assertion failed: 1: [object Map]

Esto verificará si la variable de anidamiento indeterminado 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")) {

El operador de encadenamiento opcional proporciona una manera de simplificar el acceso a los valores a través de objetos conectados cuando es posible que una referencia o función sea indefinida o nula.

let customer = {
  name: "Carl",
  details: {
    age: 82,
    location: "Paradise Falls" // detailed address is unknown
  }
};
let customerCity = customer.details?.address?.city;

El operador de fusión nulo puede usarse después del encadenamiento opcional para generar un valor predeterminado cuando no se encontró ninguno:

let customer = {
  name: "Carl",
  details: { age: 82 }
};
const customerCity = customer?.city ?? "Unknown city";
console.log(customerCity); // Unknown city

function notEmpty(value){
  return (typeof value !== 'undefined' && value.trim().length);
}

también verificará los espacios en blanco ('') junto con lo siguiente:

• nulo, indefinido, NaN, vacío, cadena (""), 0, falso

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

var ? function_if_exists() : function_if_doesnt_exist();