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

¿Existe una función universal de JavaScript que compruebe que una variable tenga un valor y se asegure de que no lo sea? undefined or null? Tengo este código, pero no estoy seguro de si cubre todos los casos:

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

preguntado el 01 de abril de 11 a las 12:04

Protip, nunca lo hagas (truthy statement) ? true : false;. Solo haz (truthy statement);. -

@GeorgeJempty no es un dup, ya que la otra respuesta pregunta sobre instrumentos de cuerda en particular, mientras que éste pregunta sobre las variables. -

Cualquier respuesta correcta a esta pregunta depende completamente de cómo defina "en blanco". -

@Jay No duele nada en cuanto a la ejecución de su código. Es demasiado detallado. No dirías: "¿Tienes hambre, es verdad?" Solo tienes "¿Tienes hambre?" Así que en el código solo di if (hungry) … en lugar de if (hungry === true) …. Como todas las cosas de codificar de esta manera, es solo una cuestión de gustos. Más específico en el ejemplo proporcionado por el OP, él está diciendo de manera aún más prolija: "Si es cierto, entonces verdadero, si no, falso" Pero si es cierto, entonces ya es cierto. Y, si es falso, ya es falso. Esto es similar a decir "Si tienes hambre, entonces la tienes, y si no, no la tienes". -

30 Respuestas

Puede comprobar si el variable tiene un truthy valor o no. Eso significa

if( value ) {
}

evaluará a true if value is no:

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

La lista anterior representa todos los posibles falsy valores en ECMA- / Javascript. Encuéntralo en el especificación en el ToBoolean .

Además, si no sabes qué si existe una variable (es decir, si fue declaró ) debe consultar con el typeof operador. Por ejemplo

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

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

contestado el 29 de mayo de 21 a las 01:05

¿Qué pasa si el valor es un booleano falso que se pretendía? A veces, desea dar un valor predeterminado si no hay ningún valor, lo que no funcionará si se pasó un booleano falso. TruMan1

@ TruMan1: en tal caso (donde su lógica dicta la validación) tiene que ir como if( value || value === false ). Lo mismo vale para todos valores falsos, necesitamos validarlos explícitamente. - jAndy

Excepto si el valor es una matriz. La interpretación de truthy podría ser engañoso. En ese caso deberíamos estar comprobando value.length != 0 para una matriz no vacía. - usuario

Solo quiero agregar que si sientes el if construct es sintácticamente demasiado pesado, podría usar el operador ternario, así: var result = undefined ? "truthy" : "falsy". O si solo quiere forzar a un valor booleano, use el !! operador, por ejemplo !!1 // true, !!null // false. - KFL

También tenga en cuenta que esto no buscará cadenas que solo contengan caracteres de espacio en blanco. - christophe roussy

El método detallado para verificar si el valor no está definido o es nulo es:

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

También puedes utilizar la == operador, pero esto espera que uno conoce todas las reglas:

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

Respondido 18 Jul 18, 13:07

Comprobando solo null or undefined se puede hacer así: if (value == null). Cuidado con el == operador que coacciona. Si marca así if (value === null || value === undefined), olvidó / no sabe cómo coacciona Javascript. webreflection.blogspot.nl/2010/10/… - Christiaan Westerbeek

@ChristiaanWesterbeek: su punto de que arg == null produce los mismos resultados que arg === undefined || arg === null. Sin embargo, considero que el último ejemplo es más legible. - salman a

arg == null es bastante común en mi experiencia. - bryan bajando

return value === (void 0) es más seguro que probar contra undefined que bien puede ser una variable legítima en su alcance, lamentablemente. - XxNUMXn

@Sharky Hay una diferencia entre una variable que no está definida y una variable no declarada: lucybain.com/blog/2014/null-undefined-undeclared - Christiaan Westerbeek

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

Esto volverá a ser cierto para

undefined  // Because undefined == null

null

[]

""

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

Para no permitir la última categoría, es posible que desee comprobar si hay cadenas en blanco

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

Respondido 16 Feb 15, 17:02

undefined == null pero undefined !== null - Ian Boyd

@IanBoyd eso se debe a que estás comparando == con ===. esto significa que undefined == null (true) undefined! = null (false) undefined === null (false) undefined! == null (true) sería mejor dar un poco más de información para ser útil y empujar a la gente en la dirección correcta. moz doc sobre la diferencia desarrollador.mozilla.org/en-US/docs/Web/JavaScript/… - corey joven

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

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

Cubrirá los casos en los que propuesta de 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)
  • false
  • Yaya

Editado: Cambiado a igualdad estricta (! ==) porque es la norma a estas alturas;)

Respondido el 02 de enero de 20 a las 12:01

No voté en contra, pero con respecto a la comparación estricta de igualdad, la regla general es que, a menos que necesitas Se debe utilizar una conversión de tipo implícita que la comparación estricta. - J.Steve

Gracias por tu comentario Steve. Esa regla general está bien. Solo espero que las personas entiendan por qué usan uno u otro. De cualquier forma que mires, las personas estarán encantadas de predicarte sobre "siempre usa siempre estricto", como si fuera lo más importante en Javascript. He visto demasiados casos como si (val! == nulo) que obviamente conducen a un resultado no deseado. Está bien decir eso en caso de duda, use estricto, pero es mejor no tener dudas. - guya

Creo que el punto aquí es que esperamos typeof operador para devolver una cadena, por lo que el uso de la comprobación de igualdad estricta es técnicamente más preciso, más específico y más rápido. Entonces, realmente, no hay razón para usar la comparación imprecisa, no al revés. También val !== null es perfectamente válido en muchos casos, lo hago todo el tiempo. Estoy de acuerdo con su argumento de no conformidad, pero creo que este es un mal ejemplo para hacerlo. Sin intentar engañarte. - bryan bajando

Gracias por tu comentario Bryan, usas val! == null porque sabes lo que estás haciendo. Un principiante querrá tener una alternativa cuando val es falso. Pero, val nunca será nulo, estará indefinido. Si tan solo no escuchara ese consejo de "usar siempre siempre estricto", tendrá menos errores. He visto que esto sucede en el código de producción. typeof siempre devuelve una cadena y la diferencia de velocidad será redundante. Entonces, el único argumento para usar estricto en el caso anterior es la coherencia. He dicho "No hay necesidad de una igualdad estricta". No significa que no pueda si lo desea o si hace que su código sea más consistente. - guya

@guya ¡Esto merece un voto simplemente por la edición después de 7 años! Especialmente teniendo en cuenta la discusión anterior en el día;) ¡Felicitaciones, señor! - rmcsharry

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 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 vinculación (: :) no es parte de ES2016 (ES7) ni de ninguna edición posterior del estándar ECMAScript. Actualmente es una propuesta de etapa 0 (de paja) para ser introducido en el lenguaje". - Simon Kjellberg. el autor desea sumar su apoyo a esta hermosa propuesta para recibir la ascensión real.

Respondido 14 ago 18, 20:08

+1 es útil conocer el objeto de tipo 'regexp', 'matriz' y 'función' - Yash

@Vix, ¿por qué la versión ES7 es mejor? - GollyJer

No lo es, estaba experimentando con formas más legibles de expresar la misma funcionalidad haciendo uso de: asignación de desestructuración, operador de enlace. - Vix

Tenga en cuenta que el operador de enlace (::) no forma parte de ES2016 (ES7) ni ninguna edición posterior del estándar ECMAScript en absoluto. Actualmente es una propuesta de etapa 0 (hombre de paja) para ser introducido en el idioma. - Simón Kjellberg

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)

or

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

respondido 19 mar '14, 13:03

eee ... creo que esto está mal, como si (valor) fuera suficiente (excepto objetos / matrices vacías). si el valor es 'indefinido', la configuración 'si' no pasará. - Oskar Szura

Esto combina variables que no están definidas (que arrojan un ReferenceError en la evaluación), que son diferentes a las variables con el undefined valor. - qantas 94 pesado

Tengo el mismo error aquí. if (x), if (! x), if (!! x) arrojarán error si x no está definido. - shaosh

if(value === 0) gameOver(); ;) - Madbreaks

Esta respuesta también es incorrecta porque devuelve falso cuando value es cero, que es no lo que busca op. - Madbreaks

Una solución que me gusta mucho:

Definamos que una variable en blanco es nullo 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:

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

Respondido 14 Oct 19, 03:10

Esta verificación de condición

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

es todo lo que necesitas.

Respondido el 03 de junio de 17 a las 20:06

Supongo que esto es solo un fragmento. Pero if ya hace una verificación falsa, que esto simplemente convierte en un booleano. ¿Detecta algún caso que sea normal? if(foo) no coge? - dan van hulst

Esto es perfecto para cuando necesita algo en línea, por ejemplo, necesito un atributo de reacción (llamado activo) que sea verdadero cuando una cadena no está vacía; una declaración if sería excesiva, así que puedo usar active={!!foo} - Ben Kolya Mansley

A menos que foo sea 0 - Gorki

! comprobar cadenas vacías (""), nulo, indefinido, falso y el número 0 y NaN. Di, si una cadena está vacía var name = "" luego console.log(!name) devoluciones true.

function isEmpty(val){
  return !val;
}

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

O

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

contestado el 08 de mayo de 19 a las 08:05

Esto realmente no dice si la variable está vacía, ya que falso y 0 pueden ser valores válidos y no constituyen un valor vacío. El valor de tener una función isEmpty sería asegurarse de que los valores que espera que estén vacíos devuelvan verdaderos. en mi opinión, null, undefined, NaN y una cadena vacía son los valores que tienen sentido como vacíos. - corey joven

¿Por qué utilizar isEmpty(val) si pudieras hacer !val? - allen linatoc

Es tu decision. Puede usarlo para aumentar la legibilidad. De lo contrario, si cree que el equipo en el que trabaja es un codificador más avanzado, puede usar solo !val or !!val de acuerdo con el dominio de su problema. - Arif

Estás exagerando un poco. Para verificar si una variable no tiene un valor, solo necesitaría verificar con undefined y null.

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

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

Respondido 01 Abr '11, 16:04

Eche un vistazo al nuevo ECMAScript Operador coalescente nulo

Puede pensar en esta característica: la ?? operador - como una forma de "retroceder" a un valor predeterminado cuando se trata de null or undefined.

let x = foo ?? bar();

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

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

respondido 17 mar '20, 17:03

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;

}

Respondido 12 Feb 14, 15:02

Hice una prueba con varios métodos aquí. Con una verificación de indefinido, su función funciona muy bien. Así que uso if (typeof value! == 'undefined' &&! IsEmpty (value)) O, si realmente desea verificar si está vacío, puede usar if (typeof value === 'undefined' || IsEmpty2 (value) ). Esto funcionará para nulo; Indefinido; 0; ""; ""; falso - Conejo Racional

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 guión bajo o lodash, intente:

_.isEmpty(value)

Respondido 21 ago 15, 14:08

Probé tu código. Recibo un mensaje de error en la consola que dice: "Error de referencia no detectado: isArray () no está definido". De lo contrario, sería genial si funcionara. - crmprogdev

En el caso de lodash al menos, _.isNil es la función que estás buscando, no _.isEmpty. documentación de isNil, Documentación isEmpty - Snixtor

Esto fallaría si el valor es booleano y tiene el valor verdadero. - kalyanbk

JavaScript simple no tiene isArray or isString funciones en el window. - GFoley83

@ l3x: ¿Eso es una broma? - Ry- ♦

return val || 'Handle empty variable'

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

const res = val || 'default value'

Respondido el 04 de diciembre de 18 a las 12:12

Muchos lugares, pero no cuando el valor predeterminado es true y estás intentando suministrar o devolver un val of false. - Molomby

@Molomby es un caso de borde muy específico, pero incluso eso se maneja fácilmente const res = falsyValue ? true : falsyValue - zorrocubo

Si la variable no ha sido declarada, no podrá probar indefinida usando 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 desea probar si se ha declarado foo y tiene un valor que puede usar

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

Respondido 01 Abr '11, 16:04

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

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

Respondido 09 Abr '17, 06:04

Operadores de comparación cheques == [Datos]. === [Datos, tipo de objeto] Los números JS siempre se almacenan como números de punto flotante de doble precisión, siguiendo el estándar internacional IEEE 754. // Number Type [int, float literals ] var int = 77; var float = 77.7; console.log( int.toFixed(10) + '\t' + float.toFixed(10) ); // Object Type var number = new Number( 77 ); if( int != float ) console.log('Data Not Equal'); if( int == number && int !== number ) console.log('Data is Equal & Types vary'); - Yash

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 recorte 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
}

Respondido 05 Oct 18, 15:10

gran función, gracias! maneja todo tipo de valor - ¡los números se omiten en todas las demás soluciones! - Fabián von Ellerts

@FabianvonEllerts No intente editar código adicional en la respuesta de otra persona. Publíquelo como su propia respuesta, como un comentario debajo de la respuesta, o solicite en un comentario que ellos mismos actualicen la respuesta. - tylerh

Puede ser útil.

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

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

Respondido el 14 de junio de 19 a las 11:06

podría explicar por favor. Que esta pasando ahí - josekisb

La matriz contiene alguna variable que asumió como vacía. - ddagsan

@JoshKisb todos los valores en la matriz representan lo que quieres ser (nulo, indefinido u otras cosas) y buscas lo que quieres en él. - ddagsan

@ddagsan Si bien JoshKisb puede agradecer su respuesta, debe poner su explicación en su respuesta en lugar de en los comentarios: Nick

La respuesta probablemente más corta es

val==null || val==''

si cambia el lado derecho a val==='' entonces la matriz vacía dará falso. Prueba

function isEmpty(val){
    return val==null || val==''
}

// ------------
// TEST
// ------------

var log = (name,val) => console.log(`${name} -> ${isEmpty(val)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" - so we should get here TRUE

Más detalles acerca de == (Fuente aquí)

Ingrese la descripción de la imagen aquí

BONUS: Razón por qué === es mas claro que ==

Ingrese la descripción de la imagen aquí

Para escribir código claro y fácil de entender, use una lista explícita de valores aceptados

val===undefined || val===null || val===''|| (Array.isArray(val) && val.length===0)

function isEmpty(val){
    return val===undefined || val===null || val==='' || (Array.isArray(val) && val.length===0)
}

// ------------
// TEST
// ------------

var log = (name,val) => console.log(`${name} -> ${isEmpty(val)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" - so we should get here TRUE

contestado el 11 de mayo de 20 a las 10:05

¡Visualización útil! ¿Cuál es la fuente de ellos? - viam0zah

@ viam0Zah, el enlace a la fuente está debajo del fragmento -> (source here) - Kamil Kielczewski

Vacuidad

No recomiendo intentar 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', belly: 'empty'}`, ¿debería `isEmpty (human)` devolver `true`? Si tengo `let reg = new RegExp ('');`, debería `isEmpty (reg)` devolver `true`? ¿Qué pasa con `isEmpty ([null, null, null, null])` - esta lista solo contiene vacíos, entonces la lista en sí está vacía? 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 de forma genérica.

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 "veraces" o "falsos". Naturalmente, tanto "nulo" como "indefinido" son "falsos". De forma menos natural, el número "0" (y ningún otro número excepto "NaN") también es "falso". Al menos naturalmente: `` '`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 sobre `null` vs` undefined` - ¿realmente necesitamos ambos para expresar vacuidad 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 "nulo" para significar "vacuidad". Una vez más, sin embargo, necesitamos acomodar el sentido inherente de javascript de cómo difieren `null` y` undefined`:
  • 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 los valores predeterminados solo cuando se proporcionan undefinedno, null:

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


Vacuidad no genérica

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

let isType = (value, Cls) => {
  // Intentional use of loose comparison operator detects `null`
  // and `undefined`, and nothing else!
  return value != null && Object.getPrototypeOf(value).constructor === Cls;
};

Tenga en cuenta que esta función ignora el polimorfismo; espera value ser una instancia directa de Cls, y no una instancia de una subclase de Cls. yo evito instanceof por 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.getPrototypeOf se usa para evitar un caso como let v = { constructor: String }; Los programas isType la función todavía regresa correctamente para isType(v, String) (falso) y isType(v, Object) (cierto).

En general, recomiendo usar este isType funcionar 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);, nuestros v La variable ahora es de tipo desconocido. Lo antes posible, debemos limitar nuestras posibilidades. La mejor manera de hacer esto puede ser requiriendo un tipo particular: p. Ej. 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 vy asegúrese de que siempre sea un Array. A veces, sin embargo, debemos permitir v ser de varios tipos. En esos casos, deberíamos crear bloques de código donde v ya no es 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, busque esas 3 posibilidades "blancas" y arroje un Error si ninguna de las 3 está satisfecha. Deberíamos poder ver que comprobar las posibilidades "negras" no es muy útil: digamos que escribimos if (v === null) throw new Error('Null value rejected'); - esto es genial para asegurar que null los valores no lo logran, pero si un valor lograrlo, todavía sabemos casi nada al respecto. Un valor v que pasa esta verificación nula sigue siendo MUY genérico, es todo menos null! Las listas negras difícilmente disipan el carácter genérico.
  • A menos que un valor sea null, nunca considere "un valor vacío". En su lugar, considere "una X que es vacía". Esencialmente, nunca considere hacer algo como if (isEmpty(val)) { /* ... */ } - no importa como eso isEmpty La función está implementada (no quiero saber ...), ¡no tiene sentido! ¡Y es demasiado genérico! La vacuidad solo debe calcularse con conocimiento de valtipo de. Las comprobaciones de vacuidad deberían verse así:
    • "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 null se utiliza para indicar cierta funcionalidad. En este caso, es significativo decir: "Un valor vacío": if (val === null) ...

Respondido el 22 de enero de 21 a las 18:01

Puedo ver que has pensado en esto:> - Rui Marqués

Si está utilizando TypeScript y no quiero dar cuenta de "valores que son false" entonces esta es la solución para ti:

Primero: import { isNullOrUndefined } from 'util';

Entonces: isNullOrUndefined(this.yourVariableName)

Tenga en cuenta: como se mencionó a continuación esto ahora está en desuso, use value === undefined || value === null preferiblemente. ref..

Respondido 05 Oct 18, 03:10

Pensé que esto era genial, así que inicialmente anulé el voto, pero es una cosa de Node.js que ha quedado obsoleta. El archivo de definiciones de tipo dice: /** @deprecated since v4.0.0 - use "value === null || value === undefined" instead. */ - átomo atómico

@atomictom pensé que es un typescript cosa. ¿Puede proporcionar el enlace de su documentación? - Barba Negra

Aquí: nodejs.org/api/util.html#util_util_isnullorundefined_object. Además: "Pensé que esto era genial, así que inicialmente votado a favor"que debería leer :) - átomo atómico

¿Por qué desaprobarían una cosa tan útil y simple como esta? geeeeees. - TIC Tac

Prueba con una 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);
    }
}

Respondido el 02 de enero de 20 a las 10:01

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

Respondido el 02 de junio de 17 a las 09:06

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

Esto nunca arrojará un error. Si miObjeto, sus hijoso miValor es nulo entonces miNuevoValor será nulo. No se lanzarán errores

Respondido el 20 de junio de 17 a las 21:06

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

Respondido el 02 de diciembre de 17 a las 09:12

Si desea evitar ser verdadero si el valor es cualquiera de los siguientes, de acuerdo con La respuesta de jAndy:

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

Una posible solución que podría evitar obtener valores veraces 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 or matriz esta vacio:

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: hasOwnProperty devuelve verdadero para cadenas vacías, 0, falso, NaN, nulo e indefinido, si la variable se declaró como alguna de ellas, por lo que podría no ser la mejor para usar. La función puede modificarse para usarla y mostrar que fue declarada, pero no se puede usar.

respondido 06 nov., 19:06

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 😁

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 del ensayo:

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

Respondido 23 Abr '20, 09:04

gran función, todas las otras respuestas aquí tenían múltiples problemas que el suyo parece abordar, solo desearía haberlo encontrado antes de escribir el mío: p pensé que le gustaría echar un vistazo a mi trabajo stackoverflow.com/questions/5515310/… Ambas funciones parecen tener exactamente el mismo resultado, pero he reducido un poco el código. Por favor, avíseme si me he perdido algo. - Sean Barandilla

👍 ¿Probaste mis "pruebas de los pobres"? Creo que terminé agregando más pruebas en la función para casos especiales como Map, WeakMap y tal vez también Date, RegExp. ¿Estás seguro de tu value.constructor === Object? Comprobar este. - Pascual Polleunus

Sí, ejecuté sus pruebas, gracias por ellas, nuestras dos funciones devuelven los mismos resultados con nuestras dos pruebas. Sigo preguntándome si me falta algo fuera de estos casos de prueba. Yo creo value.constructor === Object está bien, en javascript las declaraciones IF OR tienen orden de ejecución, por lo que la declaración OR solo se ejecutará si la anterior no devolvió VERDADERO y ya hemos verificado Null. De hecho, el único propósito de esa última declaración OR es detectar {} y asegúrese de que no devuelva VERDADERO por cosas que no debería. - Sean Barandilla

El operador de encadenamiento opcional proporciona una forma de simplificar el acceso a valores a través de objetos conectados cuando es posible que una referencia o función no esté definida o sea 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 nula se puede usar después del encadenamiento opcional para construir 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

contestado el 06 de mayo de 20 a las 11:05

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

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

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

Respondido el 02 de junio de 20 a las 15:06

Esto comprobará 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 comprueba si existe la función de traducción de Google TranslateElement. Esto es equivalente a:

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

Respondido el 03 de Septiembre de 16 a las 22:09

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.