¿Cómo puedo comprobar si una variable está vacía en Javascript? Perdón por la pregunta estúpida, ¡pero soy un novato en Javascript!

if(response.photo) is empty {
    do something
else {
    do something else
}

response.photo era de JSON, y a veces podía estar vacío, ¡celdas de datos vacías! Quiero comprobar si está vacío.

6

Si está probando una cadena vacía:

if(myVar === ''){ // do stuff };

Si está buscando una variable que haya sido declarada, pero no definida:

if(myVar === null){ // do stuff };

Si está buscando una variable que puede no estar definida:

if(myVar === undefined){ // do stuff };

Si está marcando ambos, es decir, cualquiera de las variables es nula o indefinida:

if(myVar == null){ // do stuff };

6

Esta es una pregunta más importante de lo que piensas. Las variables pueden vaciarse de muchas formas. Depende un poco de lo que necesites saber.

// quick and dirty will be true for '', null, undefined, 0, NaN and false.
if (!x) 

// test for null OR undefined
if (x == null)  

// test for undefined OR null 
if (x == undefined) 

// test for undefined
if (x === undefined) 
// or safer test for undefined since the variable undefined can be set causing tests against it to fail.
if (typeof x == 'undefined') 

// test for empty string
if (x === '') 

// if you know its an array
if (x.length == 0)  
// or
if (!x.length)

// BONUS test for empty object
var empty = true, fld;
for (fld in x) {
  empty = false;
  break;
}

4

Esto debería cubrir todos los casos:

function empty( val ) {

    // test results
    //---------------
    // []        true, empty array
    // {}        true, empty object
    // null      true
    // undefined true
    // ""        true, empty string
    // ''        true, empty string
    // 0         false, number
    // true      false, boolean
    // false     false, boolean
    // Date      false
    // function  false

        if (val === undefined)
        return true;

    if (typeof (val) == 'function' || typeof (val) == 'number' || typeof (val) == 'boolean' || Object.prototype.toString.call(val) === '[object Date]')
        return false;

    if (val == null || val.length === 0)        // null or 0 length array
        return true;

    if (typeof (val) == "object") {
        // empty object

        var r = true;

        for (var f in val)
            r = false;

        return r;
    }

    return false;
}

1

Veo posibles deficiencias en muchas de las soluciones publicadas anteriormente, así que decidí compilar la mía propia.
Nota: usa Array.prototype.some, compruebe el soporte de su navegador.

La siguiente solución considera que la variable está vacía si se cumple una de las siguientes condiciones:

  1. JS piensa que la variable es igual a false, que ya cubre muchas cosas como 0, "", [], e incluso [""] y [0]
  2. El valor es null o su tipo es 'undefined'
  3. Es un objeto vacio
  4. Es un objeto / matriz que consta de solamente de valores que están vacíos (es decir, divididos en primitivas, cada parte es igual a false). Comprueba la exploración de forma recursiva en la estructura Object / Array. P.ej

    isEmpty({"": 0}) // true
    isEmpty({"": 1}) // false
    isEmpty([{}, {}])  // true
    isEmpty(["", 0, {0: false}]) //true
    

Código de función:

/**
 * Checks if value is empty. Deep-checks arrays and objects
 * Note: isEmpty([]) == true, isEmpty({}) == true, isEmpty([{0:false},"",0]) == true, isEmpty({0:1}) == false
 * @param value
 * @returns {boolean}
 */
function isEmpty(value){
  var isEmptyObject = function(a) {
    if (typeof a.length === 'undefined') { // it's an Object, not an Array
      var hasNonempty = Object.keys(a).some(function nonEmpty(element){
        return !isEmpty(a[element]);
      });
      return hasNonempty ? false : isEmptyObject(Object.keys(a));
    }

    return !a.some(function nonEmpty(element) { // check if array is really not empty as JS thinks
      return !isEmpty(element); // at least one element should be non-empty
    });
  };
  return (
    value == false
    || typeof value === 'undefined'
    || value == null
    || (typeof value === 'object' && isEmptyObject(value))
  );
}

2

Aquí mi solución más sencilla.

Inspirado por PHP empty función

function empty(n){
	return !(!!n ? typeof n === 'object' ? Array.isArray(n) ? !!n.length : !!Object.keys(n).length : true : false);
}

//with number
console.log(empty(0));        //true
console.log(empty(10));       //false

//with object
console.log(empty({}));       //true
console.log(empty({a:'a'}));  //false

//with array
console.log(empty([]));       //true
console.log(empty([1,2]));    //false

//with string
console.log(empty(''));       //true
console.log(empty('a'));      //false

Ver http://underscorejs.org/#isEmpty

isEmpty_.isEmpty (objeto) Devuelve verdadero si un objeto enumerable no contiene valores (no hay propiedades propias enumerables). Para cadenas y objetos tipo matriz, _.isEmpty comprueba si la propiedad de longitud es 0.

Combinando respuestas de @inkednm en una función:

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

1

La verificación vacía en la clave de un JSON depende del caso de uso. Para un caso de uso común, podemos probar lo siguiente:

  1. No null
  2. No undefined
  3. No es una cadena vacía ''
  4. No es un objeto vacío {} [] (La matriz es un objeto)

Función:

function isEmpty(arg){
  return (
    arg == null || // Check for null or undefined
    arg.length === 0 || // Check for empty String (Bonus check for empty Array)
    (typeof arg === 'object' && Object.keys(arg).length === 0) // Check for empty Object or Array
  );
}

Devuelve verdadero para:

isEmpty(''); // Empty String
isEmpty(null); // null
isEmpty(); // undefined
isEmpty({}); // Empty Object
isEmpty([]); // Empty Array

Una versión más legible de @ SJ00 respuesta:

/**
 * Checks if a JavaScript value is empty
 * @example
 *    isEmpty(null); // true
 *    isEmpty(undefined); // true
 *    isEmpty(''); // true
 *    isEmpty([]); // true
 *    isEmpty({}); // true
 * @param {any} value - item to test
 * @returns {boolean} true if empty, otherwise false
 */
function isEmpty(value) {
    return (
        value === null || // check for null
        value === undefined || // check for undefined
        value === '' || // check for empty string
        (Array.isArray(value) && value.length === 0) || // check for empty array
    ...