¿Cómo pruebo un objeto JavaScript vacío?

3860

Después de una solicitud AJAX, a veces mi aplicación puede devolver un objeto vacío, como:

var a = {};

¿Cómo puedo comprobar si ese es el caso?

3
  • 10
    ¿Utiliza el script JSON.js? O cualquier otra biblioteca JSON. Luego puede usar la función JSON.encode () para convertir var en cadena y luego probarlo. Thevs 25 de marzo de 2009 a las 13:50
  • 14
    Solo buscaif (Object.keys(obj).length === 0) { // handle empty obj }Gabriel Petersson 22/07/20 a las 14:27
  • 6
    @GabrielPetersson Por favor, nunca proporcione soluciones como comentarios. Su comentario es una violación del diseño de página muy claro / simple de esta sección de preguntas y respuestas. El consejo de resolución se publicará como respuesta. Los comentarios bajo la pregunta deben solicitar al PO una aclaración u ofrecer ideas que no resuelvan. meta.stackexchange.com/a/296481/352329mickmackusa 4 de agosto de 2020 a las 5:53
6611

ECMA 5+ :

// because Object.keys(new Date()).length === 0;
// we have to do some additional check
obj // 👈 null and undefined check
&& Object.keys(obj).length === 0 && obj.constructor === Object

Sin embargo, tenga en cuenta que esto crea una matriz innecesaria (el valor de retorno de keys).

Pre-ECMA 5:

function isEmpty(obj) {
  for(var prop in obj) {
    if(obj.hasOwnProperty(prop)) {
      return false;
    }
  }

  return JSON.stringify(obj) === JSON.stringify({});
}

jQuery :

jQuery.isEmptyObject({}); // true

lodash :

_.isEmpty({}); // true

Subrayado :

_.isEmpty({}); // true

Esquina

Hoek.deepEqual({}, {}); // true

ExtJS

Ext.Object.isEmpty({}); // true

AngularJS (versión 1)

angular.equals({}, {}); // true

Ramda

R.isEmpty({}); // true
3
  • 34
    Object.keys(new Date()).length === 0; por lo que esta respuesta puede ser engañosa. cjbarth 1 de marzo de 2016 a las 16:34
  • ¿Por qué tenemos que comprobar obj.contructor===Objecten el ECMA5+código? Solo podemos usar este códigoobj // 👈 null and undefined check && Object.keys(obj).length === 0Rishabh Raghwendra 8 de julio a las 11:54
  • El comentario justo encima del tuyo explica literalmente por qué =) Hay un millón de objetos diferentes, por lo que debes asegurarte de probar solo "primitivas de objetos reales", es decir, objetos cuyo constructor no sea una extensión de Object. Mike 'Pomax' Kamermans 1 de agosto a las 3:41
1050

Si la compatibilidad con ECMAScript 5 está disponible, puede utilizar Object.keys():

function isEmpty(obj) {
    return Object.keys(obj).length === 0;
}

Para ES3 y versiones anteriores, no hay una manera fácil de hacer esto. Tendrá que recorrer las propiedades explícitamente:

function isEmpty(obj) {
    for(var prop in obj) {
        if(obj.hasOwnProperty(prop))
            return false;
    }

    return true;
}
6
  • 66
    Esto funciona bien, o más simplemente: function isEmpty (object) {for (var i in object) {return true; } falso retorno; }niczak 24 de marzo de 2010 a las 23:23
  • 44
    ¿No deberían invertirse verdadero y falso en esta función? namtax 5 de mayo de 2010 a las 13:46
  • 35
    @namtax: no - la función tiene un nombre isEmpty(), por lo que debería regresar falsesi tiene una propiedadChristoph 6 de mayo de 2010 a las 16:31
  • @NicholasKreidberg Ese código function isEmpty(object) { for(var i in object) { return true; } return false; }se corrigió después de 11 años. Aquí está la corrección: function isEmpty(obj) { return !(() => { for (const i in obj) { return true; } return false; })(); }Michael Buen 4 de julio a las 8:52
  • Alernativamente: function isObjectEmpty(obj) { for (const i in obj) return false; return true; }Michael Buen 5 de julio a las 7:18
588

Para aquellos de ustedes que tienen el mismo problema pero usan jQuery, pueden usar jQuery.isEmptyObject .

12
  • 45
    ¡OYE! Pasé unas horas depurando problemas de IE 8 y descubrí que era jQuery.isEmptyObject el que estaba causando el problema. Devuelve verdadero si el objeto está vacío. MFD3000 17 de agosto de 2011 a las 19:03
  • 176
    ¿Por qué publica una respuesta que incluye jQuery si la pregunta no es sobre jQuery en absoluto? Eru 1/10/12 a las 14:10
  • 52
    Sé que es un comentario antiguo, pero me pregunto tu pregunta @ MFD3000, porque el documento dice: devuelve verdadero, si el objeto está vacío (como el nombre lo indica)Александр Фишер 12/12/12 a las 19:44
  • 22
    incluir jQuery para una tarea tan básica no es lo que yo llamaría la respuesta correcta. Es cierto que hoy en día jQuery es casi omnipresente, pero aún así no debemos olvidar que se basa en un lenguaje muy capaz en sí mismo. Pablo Mescher 27 feb 2013 a las 17:04
  • sesenta y cinco
    El esnobismo típico de JS en estos comentarios. Todo el mundo sabe que una gran proporción de JavaScript en la web está escrito en jQuery, por lo que es perfectamente aceptable proporcionar una solución aquí para jQuery si ya tiene un método incorporado para probar objetos. Es probable que miles de desarrolladores que buscan ayuda encuentren útil esta respuesta. Nadie dijo que es la única forma de hacerlo. Me doy cuenta de que nadie actúa todo elitista sobre el tipo que publicó una solución para usar underscore.js...BadHorsie 07/07/2015 a las 15:35
355

Esta es mi solución preferida:

var obj = {};
return Object.keys(obj).length; //returns 0 if empty or an integer > 0 if non-empty
0
221

Puede utilizar Underscore.js .

_.isEmpty({}); // true
2
  • 22
    O puede usar lodash está vacío ( lodash.com/docs#isEmpty ), pero ¿en qué se diferencia de usar una solución jQuery? Aún necesita instalar una biblioteca adicional. Creo que la intención es una solución de JavaScript de vainilla. tim-montague 23 de julio de 2014 a las 23:38
  • Si agregar toda la dependencia es mortificante para su aplicación dependiente de súper rendimiento, puede instalar solo _.isEmpty:npm i lodash.isemptyNick Bull 12 de agosto a las 12:20
199

Rendimiento

Hoy 2020.01.17 realizo pruebas en macOS HighSierra 10.13.6 en Chrome v79.0, Safari v13.0.4 y Firefox v72.0, para las soluciones elegidas.

Conclusiones

  • las soluciones basadas en for-in(A, J, L, M) son las más rápidas
  • las soluciones basadas en JSON.stringify(B, K) son lentas
  • sorprendentemente también la solución basada en Object(N) es lenta

ingrese la descripción de la imagen aquí

Detalles

Hay 15 soluciones presentadas en el fragmento a continuación. Si desea ejecutar una prueba de rendimiento en su máquina, haga clic AQUÍ . Este enlace se actualizó en 2021.07.08, pero las pruebas oryginaly se realizaron aquí , y los resultados de la tabla anterior provienen de allí (pero ahora parece que ese servicio ya no funciona).

var log = (s,f) => console.log(`${s} --> {}:${f({})}  {k:2}:${f({k:2})}`);

function A(obj) {
  for(var i in obj) return false; 
  return true;
}

function B(obj) {
  return JSON.stringify(obj) === '{}';
}

function C(obj) {
  return Object.keys(obj).length === 0;
}

function D(obj) {
  return Object.entries(obj).length === 0;
}

function E(obj) {
  return Object.getOwnPropertyNames(obj).length === 0;
}

function F(obj) {
  return Object.keys(obj).length === 0 && obj.constructor === Object;
}

function G(obj) {
  return typeof obj === "undefined" || !Boolean(Object.keys(obj)[0]);
}

function H(obj) {
  return Object.entries(obj).length === 0 && obj.constructor === Object;
}

function I(obj) {
  return Object.values( obj  ).every( val => typeof val === "undefined" );
}

function J(obj) {
  for (const key in obj) {
    if (hasOwnProperty.call(obj, key)) {
      return false
    }
  }
  return true;
}

function K(obj) {
  for(var prop in obj) {
    if(obj.hasOwnProperty(prop)) {
      return false;
    }
  }

  return JSON.stringify(obj) == JSON.stringify({});
}

function L(obj) {
  for(var prop in obj) {
    if(obj.hasOwnProperty(prop))
      return false;
  }

  return true;
}

function M(obj) {
  for (var k in obj)
  { 
    if ( obj.hasOwnProperty(k) )
    { 
      return false;
    } 
  }
  return true; 
}

function N(obj) {
  return Object.getOwnPropertyNames(obj).length === 0 &&
  Object.getOwnPropertySymbols(obj).length === 0 &&
  Object.getPrototypeOf(obj) === Object.prototype; 
}

function O(obj) {
  return !(Object.getOwnPropertyNames != undefined ? Object.getOwnPropertyNames(obj).length != 0 : (function(){for(var key in obj) break; return (key != null) && (key != undefined);})())
}

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);
log('H',H);
log('I',I);
log('J',J);
log('K',K);
log('L',L);
log('M',M);
log('N',N);
log('O',O);

ingrese la descripción de la imagen aquí

Si mi respuesta te ayudó, puedes invitarme a un café.

2
  • Mucho de esto no tiene sentido porque está basando todo en un retorno de falso o verdadero. A veces, la programación necesita una declaración if o un operador ternario. solo para tu informaciónChristian Matthew 10 abr.20 a las 7:32
  • 6
    Para completar, edité su jsperf para probar obj = {a:1,b:2,c:3}y for(var i in obj)sigue siendo el jsperf.com/object-empty-ch/2 más rápidoMadacol 13/06/20 a las 0:08
123
if(Object.getOwnPropertyNames(obj).length === 0){
  //is empty
}

ver http://bencollier.net/2011/04/javascript-is-an-object-empty/

3
  • 5
    Esto incluye propiedades no enumerables, en caso de que le importe. user663031 3 de septiembre de 2014 a las 13:33
  • El Object.getOwnPropertyNames ({}). Length es 10 veces más lento que la opción (for ... in ...) - sugiero evitarlo como una forma de probar si un objetc está vacío. davidhadas 28/12/15 a las 10:35
  • 4
    Object.getOwnPropertyNames(new Date()).length === 0; por lo que esta respuesta puede ser engañosa. cjbarth 1 de marzo de 2016 a las 16:37
94

¿Qué tal usar JSON.stringify? Está casi disponible en todos los navegadores modernos.

function isEmptyObject(obj){
    return JSON.stringify(obj) === '{}';
}
8
  • 25
    return (JSON.stringify (obj) == '{}')Vic 11/0913 a las 15:05
  • 30
    Esto es lento y la velocidad es importante para este tipo de utilidad. Prueba rápida de rendimiento aquí: jsperf.com/empty-object-testuser81962 11/06/2014 a las 6:21
  • 1
    Esta es una opción muy lenta; sugiero usar la opción (para ... en) en su lugardavidhadas 28/12/15 a las 10:33
  • 2
    Y no funciona para objetos que contienen funciones. Felix Kling 22/06/18 a las 23:27
  • 2
    También arrojará un error si hay una referencia circular en el objeto. Por lo tanto, es lento, poco confiable y puede generar errores y romper todo lo demás. No hay razón para usarlo nunca. Burak 16/01/19 a las 17:26
63

Pregunta vieja, pero acaba de tener el problema. Incluir JQuery no es realmente una buena idea si su único propósito es verificar si el objeto no está vacío. En su lugar, profundice en el código de JQuery y obtendrá la respuesta:

function isEmptyObject(obj) {
    var name;
    for (name in obj) {
        if (obj.hasOwnProperty(name)) {
            return false;
        }
    }
    return true;
}
1
  • 5
    Esto solo es útil si algún otro proceso no ha agregado un prototipo a su objeto base. Para que esto sea realmente viable, debe probar obj.hasOwnProperty (nombre)mpemburn 14 de mayo de 2014 a las 16:10
61

Acabo de encontrarme con una situación similar. No quería usar JQuery y quería hacer esto usando Javascript puro.

Y lo que hice fue utilizar la siguiente condición y funcionó para mí.

var obj = {};
if(JSON.stringify(obj) === '{}') { //This will check if the object is empty
   //Code here..
}

Para no igual a, use esto: JSON.stringify(obj) !== '{}'

Mira este JSFiddle

7
  • 6
    Fallará para objetos con referencias circulares ya que JSON.stringify arroja específicamente una excepción para ellos. Pedro Montoto García 18 de diciembre de 2014 a las 16:13
  • 2
    @ PedroMontotoGarcía Ok y ¿cómo un objeto vacío tendrá una referencia circular? KthProg 28/01/15 a las 21:18
  • 9
    Si el objeto no está vacío (y también debería funcionar para ellos). Pedro Montoto García 29 de enero de 2015 a las 10:31
  • 2
    Esto parece que ya lo mencionó @Ateszki y es una de las formas más lentas de verificar si un objeto no está vacío. cwadding 5/06/2015 a las 17:19
  • Oh, sí ... me lo perdí. Me encontré con una situación en la que quería lograr este javascript, y después de pensar un poco me di cuenta de esta manera. @ Ateszki, Incluso yo pensé en la forma en que lo hiciste. :-) Por cierto, hubo muchas respuestas sobre esto, así que me perdí tu respuesta. Anish Nair 6/06/2015 a las 10:34
43

Hay una forma sencilla si tiene un navegador más nuevo. Object.keys(obj).length == 0

5
  • 1
    ¿De donde keysviene la propiedad? user663031 3 de septiembre de 2014 a las 13:23
  • 2
    Es un método estándar en ECMAScript 5.1download 4 de septiembre de 2014 a las 22:41
  • 1
    ¿Cómo puede el comentario anterior tener 4 votos a favor? Sí, Object.keyses un método estándar, pero los objetos no tienen una propiedad de claves. Entonces, este código informará cualquier objeto como vacío, excepto que accidentalmente tenga una propiedad nombrada keycon un valor que nuevamente como una propiedad nombrada lengthque no es cero. ¡Horrible! scravy 5 de agosto de 2015 a las 14:45
  • Object.keys(new Date()).length === 0; por lo que esta respuesta puede ser engañosa. cjbarth 1 de marzo de 2016 a las 16:40
  • 15
    @scravy Object es la clase Object. El objeto tiene un método estático llamado 'claves' que acepta un objeto como argumento. Este método devuelve una matriz de cadenas donde las cadenas son nombres de propiedad. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…Sgnl 4 de ene. De 2017 a las 20:05
43

El uso de Object.keys (obj) .length (como se sugirió anteriormente para ECMA 5+) es 10 veces más lento para objetos vacíos. manténgase con la opción de la vieja escuela (para ... en).

Probado en Node, Chrome, Firefox e IE 9, resulta evidente que para la mayoría de los casos de uso:

  • (para ... en ...) es la opción más rápida de usar.
  • Object.keys (obj) .length es 10 veces más lento para objetos vacíos
  • JSON.stringify (obj) .length es siempre el más lento (no es sorprendente)
  • Object.getOwnPropertyNames (obj) .length tarda más que Object.keys (obj) .length puede ser mucho más largo en algunos sistemas.

En resumen, en cuanto al rendimiento, utilice:

function isEmpty(obj) { 
   for (var x in obj) { return false; }
   return true;
}

o

function isEmpty(obj) {
   for (var x in obj) { if (obj.hasOwnProperty(x))  return false; }
   return true;
}

Consulte los resultados detallados de las pruebas y el código de prueba en ¿El objeto está vacío?

1
  • Object.keyses lento, pero menos código. En una página pequeña, donde se llama ... quizás 10 veces ... ¿Será aún más lento considerando el tiempo de análisis adicional del código adicional? yankee 25/11/19 a las 10:43
35

Puede verificar el recuento de las claves de objeto:

if (Object.keys(a).length > 0) {
    // not empty
}
3
  • 9
    ¿Por qué agregarías un comentario para una respuesta que ya se dio y darías una peor respuesta? stackoverflow.com/a/32108184/4229159 y es la primera respuesta de abrilAlejandro Vales 13/10/2017 a las 9:21
  • 1
    ¿Qué pasa si tengo un objeto muy grande y hago eso en cada bucle solo para ver si el objeto estaba vacío? StefansArya 9 oct 2018 a las 23:57
  • Esta respuesta no parece agregar nada que la respuesta aceptada no diga. mickmackusa 4 de agosto de 2020 a las 6:10
28
  1. Solo una solución. ¿Puede su servidor generar alguna propiedad especial en caso de que no haya datos?

    Por ejemplo:

    var a = {empty:true};
    

    Luego, puede verificarlo fácilmente en su código de devolución de llamada AJAX.

  2. Otra forma de comprobarlo:

    if (a.toSource() === "({})")  // then 'a' is empty
    

EDITAR : Si usa cualquier biblioteca JSON (fe JSON.js), puede probar la función JSON.encode () y probar el resultado con una cadena de valor vacía.

11
  • 6
    toSource()no es estándar y no funciona en IE u Opera (y potencialmente en otros navegadores que no verifiqué)Christoph 25 de marzo de 2009 a las 12:21
  • 4
    @Thevs: quizás tenga una copia diferente de la versión actual de ECMA-262, pero la mía no incluye una toSourcepropiedad en la sección 15.2.4; según MDC, se introdujo en JS1.3 (es decir, Netscape Navigator 4.06), ¡pero NO en ECMA-262, tercera edición! Christoph 25 mar 09 a las 22:47
  • 4
    @Thevs: bueno, al menos 2 proveedores importantes de navegadores no lo implementaron, por lo que no es un estándar de facto, y como no está en ECMA-262, tampoco es real ...Christoph 26 mar 09 a las 9:34
  • 4
    Incluso cuando funciona, toSource()es una forma horrible de hacerlo (tal cual JSON.encode()). Necesita construir una cadena que represente todo su objeto para verificar si está vacío. Existe la sobrecarga de convertir cosas en cadenas, pero además necesitará convertir un millón de cosas si su objeto tiene un millón de propiedades, mientras que en realidad solo mirar una le permitirá saber que no está vacío. Jasper 12 de agosto de 2014 a las 8:42
  • 4
    @Thevs, la sobrecarga es mayor, incluso si pudiera ser (no estoy seguro de que sea en todas las circunstancias) en el mismo orden de magnitud. Sin embargo, esa respuesta implica devolver falso tan pronto como se encuentre una propiedad diferente, lo que hace que la historia sea diferente todos juntos ...Jasper 1 de septiembre de 2014 a las 8:32
26

As per the ES2017 specification on Object.entries(), the check is simple using any modern browser--

Object.entries({}).length === 0
3
  • 5
    ¿Hay algún beneficio al usar esto sobre Object.keyso Object.values? faintsignal 11/01/19 a las 21:05
  • @faintsignal usando esos están perfectamente bien. Acabo de agregar entradas ya que no las encontré en los comentarios. Vikrant 13/01/19 a las 5:23
  • Todavía necesito usar obj.constructor === Object, como: Object.entries(new Date()).lengthdevuelve 0. fourpastmidnight 9 de agosto a las 19:20
25

Creé una función completa para determinar si el objeto está vacío.

Utiliza Object.keysde ECMAScript 5 funcionalidad (ES5) si fuera posible lograr el mejor rendimiento (ver tabla de compatibilidad ) y retrocesos al enfoque más compatible para los motores más antiguos (navegadores).

Solución

/**
 * Returns true if specified object has no properties,
 * false otherwise.
 *
 * @param {object} object
 * @returns {boolean}
 */
function isObjectEmpty(object)
{
    if ('object' !== typeof object) {
        throw new Error('Object must be specified.');
    }

    if (null === object) {
        return true;
    }

    if ('undefined' !== Object.keys) {
        // Using ECMAScript 5 feature.
        return (0 === Object.keys(object).length);
    } else {
        // Using legacy compatibility mode.
        for (var key in object) {
            if (object.hasOwnProperty(key)) {
                return false;
            }
        }
        return true;
    }
}

Aquí está la esencia de este código.

Y aquí está el JSFiddle con demostración y una prueba simple.

Espero que ayude a alguien. ¡Salud!

4
  • 3
    Esto falla para un nullobjeto. user663031 3 de septiembre de 2014 a las 13:24
  • Hola @torazaburo! ¡Gracias por tomar nota! Actualicé todas las fuentes con la implementación correcta. Slava Fomin II 4 de septiembre de 2014 a las 12:32
  • 1
    La longitud de Object.keys ({}). Es 10 veces más lenta que la opción (for ... in ...) - sugiero evitarla como una forma de probar si un objetc está vacío. davidhadas 28/12/15 a las 10:34
  • 2
    Object.keys(new Date()).length === 0; por lo que esta respuesta puede ser engañosa. cjbarth 1 mar 16 a las 16:35
23

Mi toma:

function isEmpty(obj) {
  return Object.keys(obj).length === 0;
}

var a = {
  a: 1,
  b: 2
}
var b = {}

console.log(isEmpty(a)); // false
console.log(isEmpty(b)); // true

Simplemente, no creo que todos los navegadores se implementen Object.keys()actualmente.

2
  • 2
    Object.keys(new Date()).length === 0; por lo que esta respuesta puede ser engañosa. cjbarth 1 de marzo de 2016 a las 16:40
  • 3
    Depende si consideras que una fecha está siempre "llena" a pesar de que nunca exponga las claves. Pero estoy de acuerdo en que si ese es su plan, agregar alguna instancia complementaria de verificación para el constructor de fecha es una buena opción. NiKo 20 de marzo de 2016 a las 11:31
21

Estoy usando esto.

function isObjectEmpty(object) {
  var isEmpty = true;
  for (keys in object) {
     isEmpty = false;
     break; // exiting since we found that the object is not empty
  }
  return isEmpty;
}

P.ej:

var myObject = {}; // Object is empty
var isEmpty  = isObjectEmpty(myObject); // will return true;

// populating the object
myObject = {"name":"John Smith","Address":"Kochi, Kerala"}; 

// check if the object is empty
isEmpty  = isObjectEmpty(myObject); // will return false;

de aquí

Actualizar

O

puede usar la implementación jQuery de isEmptyObject

function isEmptyObject(obj) {
  var name;
  for (name in obj) {
    return false;
  }
  return true;
}
2
  • Hola. cuando prueba esta función con número o booleano verdadero o falso, devuelve verdadero y este resultado no es correcto. isObjectEmpty (verdadero). isObjectEmpty (falso). isObjectEmpty (1)iman 3 de septiembre de 2013 a las 4:40
  • 2
    Estamos comprobando si el objeto está vacío, no si el tipo de datos es un objeto. En su caso, para verificar si es un objeto, necesitamos algo como if (typeof a === "object") {...}kiranvj 3 de septiembre de 2013 a las 6:31
17
function isEmpty(obj) {
  for(var i in obj) { return false; }
  return true;
}
1
  • 4
    Eso también reportará verdadero, cuando, por ejemplo, una biblioteca de JavaScript se extiende Objectcon un método a través de la cadena de prototipos, porque eso es enumerable y la for indeclaración recorre propiedades enumerables. viam0Zah 24 '09 a las 13:20
16

El siguiente ejemplo muestra cómo probar si un objeto JavaScript está vacío, si por vacío queremos decir que no tiene propiedades propias.

El script funciona en ES6.

const isEmpty = (obj) => {
    if (obj === null ||
        obj === undefined ||
        Array.isArray(obj) ||
        typeof obj !== 'object'
    ) {
        return true;
    }
    return Object.getOwnPropertyNames(obj).length === 0;
};
console.clear();
console.log('-----');
console.log(isEmpty(''));           // true
console.log(isEmpty(33));           // true
console.log(isEmpty([]));           // true
console.log(isEmpty({}));           // true
console.log(isEmpty({ length: 0, custom_property: [] })); // false
console.log('-----');
console.log(isEmpty('Hello'));      // true
console.log(isEmpty([1, 2, 3]));    // true
console.log(isEmpty({ test: 1 }));  // false
console.log(isEmpty({ length: 3, custom_property: [1, 2, 3] })); // false
console.log('-----');
console.log(isEmpty(new Date()));   // true
console.log(isEmpty(Infinity));     // true
console.log(isEmpty(null));         // true
console.log(isEmpty(undefined));    // true
13

jQuery tiene una función especial isEmptyObject()para este caso:

jQuery.isEmptyObject({}) // true
jQuery.isEmptyObject({ foo: "bar" }) // false

Leer más en http://api.jquery.com/jQuery.isEmptyObject/

0
13

Yo iría a comprobar si tiene al menos una llave. Eso sería suficiente para decirme que no está vacío.

Boolean(Object.keys(obj || {})[0]) // obj || {} checks for undefined
6
  • 2
    ¿Qué pasa si la primera clave devuelve un falsevalor? el resultado será falseel incorrecto. Jimmy Obonyo Abor 25 de septiembre de 2018 a las 1:36
  • He probado para eso. ¿Puede dar un ejemplo práctico? Tudor Morar 25 de septiembre de 2018 a las 10:03
  • 1
    esto es breve y conciso, pero dará como resultado un error de tiempo de ejecución si el objeto no está definidoMrinmoy 4 de diciembre de 2018 a las 23:16
  • @ Jimmy Obonyo Abor ¿Cómo puede ser una llave false? Adrian Bartholomew 2 sep.2020 a las 18:05
  • 1
    @Ajay incluso si la clave es 0, la solución funcionaTudor Morar 31 mar a las 8:27
12

Bajo el capó, todos los métodos de verificación vacíos en todas las bibliotecas utilizan la lógica de verificación de claves de objeto. Es una forma extraña de hacerlo comprensible, que puede poner en un método, descrito aquí .

for(key in obj){
   //your work here.
 break;
}

Que ha evolucionado en ES5 , ahora en pocas palabras, puede verificar la longitud de las claves del objeto, utilizando el Object.Keysmétodo que toma su objeto como parámetro:

if(Object.keys(obj).length > 0){
 //do your work here
}

O si está usando Lodash (debe estarlo) entonces.

 _.isEmpty(obj) //==true or false
1
  • Si bien es correcto como una forma extraña de hacer una declaración if, probablemente confundirá a alguien que mantendrá el código después de usted. Soren 29 de junio de 2014 a las 1:31
11


puede usar este código simple que no usó jQuery u otras bibliotecas

var a=({});

//check is an empty object
if(JSON.stringify(a)=='{}') {
    alert('it is empty');
} else {
    alert('it is not empty');
}

La clase JSON y sus funciones ( parse y stringify ) son muy útiles pero tiene algunos problemas con IE7 que puede solucionar con este simple código http://www.json.org/js.html .

Otra forma simple (la forma más sencilla):
puede utilizar esta forma sin utilizar jQuery o el objeto JSON .

var a=({});

function isEmptyObject(obj) {
    if(typeof obj!='object') {
        //it is not object, so is not empty
        return false;
    } else {
        var x,i=0;
        for(x in obj) {
            i++;
        }
        if(i>0) {
            //this object has some properties or methods
            return false;
        } else {
            //this object has not any property or method
            return true;
        }
    }
}

alert(isEmptyObject(a));    //true is alerted
1
  • JSON.stringifyLa solución falla si el objeto contiene propiedades que no se pueden establecer en cadenas, como funciones o "indefinido", aunque se reconoce que es un caso extremo. user663031 3 de septiembre de 2014 a las 13:29
11

La mejor manera que encontré:

function isEmpty(obj)
{
    if (!obj)
    {
        return true;
    }

    if (!(typeof(obj) === 'number') && !Object.keys(obj).length)
    {
        return true;
    }

    return false;
}

Trabaja para:

    t1: {} -> true
    t2: {0:1} -: false
    t3: [] -> true
    t4: [2] -> false
    t5: null -> true
    t6: undefined -> true
    t7: "" -> true
    t8: "a" -> false
    t9: 0 -> true
    t10: 1 -> false
1
  • 3
    Yo diría que 0 no está vacío ya que en realidad es un número. todo lo demás se ve bien, pero la solución es fácil. en la primera declaración if agregue esto. if (!obj && obj !== 0). mjwrazor 1 de junio de 2017 a las 15:10
9

Si jQuery y el navegador web no están disponibles, también hay una función isEmpty en underscore.js.

_.isEmpty({}) // returns true

Además, no asume que el parámetro de entrada sea un objeto. Para una lista o cadena o indefinida, también se convertirá en la respuesta correcta.

1
9

La respuesta correcta es:

const isEmptyObject = obj =>
  Object.getOwnPropertyNames(obj).length === 0 &&
  Object.getOwnPropertySymbols(obj).length === 0 &&
  Object.getPrototypeOf(obj) === Object.prototype;

Esto comprueba que:

  • El objeto no tiene propiedades propias (independientemente de la enumerabilidad).
  • El objeto no tiene símbolos de propiedad propios.
  • El prototipo del objeto es exactamente Object.prototype.

En otras palabras, el objeto es indistinguible de uno creado con {}.

9

Una solución más simple: el var a = {};
caso a está vacío : !Object.keys(a).lengthdevuelve true.

8

Además de la respuesta de Thevs:

var o = {};
alert($.toJSON(o)=='{}'); // true

var o = {a:1};
alert($.toJSON(o)=='{}'); // false

es jquery + jquery.json

2
  • No me gusta usar JSON porque no puede funcionar con estructuras de objetos circulares. itdoesntwork 3 de enero de 2013 a las 18:28
  • 3
    Si su página carga jQuery, use $.isEmptyObject(), no desperdicie ciclos con conversiones no obvias. skierpage 7 de febrero de 2015 a las 2:17
8

¡Consideración! Tenga cuidado con las limitaciones de JSON.

javascript:
  obj={  f:function(){}  };
  alert( "Beware!! obj is NOT empty!\n\nobj = {  f:function(){}  }" + 
               "\n\nJSON.stringify( obj )\n\nreturns\n\n" +
                        JSON.stringify( obj ) );

muestra

    Beware!! obj is NOT empty!

    obj = {  f:function(){}  }

    JSON.stringify( obj )

    returns

    {}