Cómo verificar si un objeto de JavaScript está vacío: 5 formas prácticas

«¿El objeto está vacío o no?» Analicemos el eterno dolor de cabeza del desarrollador de JavaScript

Imagina: estás escribiendo una aplicación, recibes una respuesta de la API y necesitas saber: ¿llegaron los datos? ¿O el objeto está vacío y es momento de mostrarle al usuario un marcador de posición? ¿O estás procesando un formulario y necesitas verificar si el usuario llenó al menos un campo? Una situación dolorosamente familiar para cualquiera que escriba en JavaScript.

¿Parecería que podría ser más simple? if (obj === {}) — ¿y listo? Lamentablemente, no. En JavaScript, dos objetos, incluso con contenido absolutamente idéntico, nunca serán iguales entre sí, a menos que sean el mismo objeto en memoria. Verificar si un objeto de JavaScript está vacío es esa tarea que ha acumulado miles de visitas en Stack Overflow y ha generado toda una industria de soluciones.

En este artículo, analizaremos 5 formas confiables de determinar si tienes un objeto vacío. Desde las clásicas hasta las modernas, desde las rápidas hasta las seguras. ¡Allá vamos!

¿Qué significa «objeto vacío» en JavaScript?

Antes de lanzarnos al código, acordemos los términos. Un objeto vacío en JavaScript es un objeto que no tiene propiedades enumerables propias. Es decir, {} está vacío. Pero { name: "Alice" } ya no lo está.

Un detalle importante: cualquier objeto tiene un prototipo (Object.prototype), y por lo tanto, tiene propiedades heredadas (por ejemplo, toString, hasOwnProperty). A nosotros no nos interesan. Solo verificamos lo que hemos agregado nosotros mismos.

Otro escollo es null. Si una variable es igual a null o undefined, ni siquiera podemos llamar a sus métodos. Por lo tanto, lo primero es siempre verificar que el objeto exista.

Forma 1: Object.keys() — el estándar de oro

La forma más popular y recomendada en JavaScript moderno. El método Object.keys() devuelve un array de las propiedades enumerables propias del objeto. Si el array está vacío, el objeto está vacío.

function isEmpty(obj) {\n    return Object.keys(obj).length === 0;\n}\n\n// Ejemplos de uso\nconsole.log(isEmpty({}));           // true\nconsole.log(isEmpty({a: 1}));       // false\nconsole.log(isEmpty({name: 'John', age: 30})); // false

¿Por qué funciona esto? Object.keys() ignora las propiedades heredadas y devuelve solo lo que pertenece al objeto mismo. Verificar si un objeto está vacío con Object.keys() es código limpio, legible y rápido.

Importante: Este método no verifica si el valor pasado es un objeto. Si se pasa una cadena o un número, devolverá un array vacío, y erróneamente pensaremos que el objeto está vacío. Por lo tanto, para mayor seguridad, agregamos una verificación de tipo:

function isEmptySafe(obj) {\n    return obj && typeof obj === 'object' && Object.keys(obj).length === 0;\n}\n\nconsole.log(isEmptySafe('hello')); // false (la cadena no es un objeto)\nconsole.log(isEmptySafe(null));    // false\nconsole.log(isEmptySafe({}));      // true

Forma 2: JSON.stringify() — inesperada pero funcional

A veces los programadores llaman en broma a este método «muleta», pero funciona. La idea es simple: serializar el objeto a una cadena JSON y compararla con '{}'.

function isEmptyJSON(obj) {\n    return JSON.stringify(obj) === '{}';\n}\n\nconsole.log(isEmptyJSON({}));           // true\nconsole.log(isEmptyJSON({key: 'val'})); // false

¿Por qué este método no es ideal? En primer lugar, JSON.stringify() ignora funciones, undefined y símbolos. Si un objeto tiene una propiedad con valor undefined, simplemente desaparecerá al serializar, y el objeto se considerará vacío, aunque en realidad tenga una clave.

const obj = { a: undefined };\nconsole.log(isEmptyJSON(obj)); // true — ¡pero debería ser false!

En segun