Eliminar valores null en JSON: qué se borra y qué queda

Contenido
- Por qué acabas necesitando esta limpieza
- Cómo hacerlo por tu cuenta sin ninguna herramienta
- Los puntos que más confunden
- En resumen
- Mecanismos técnicos clave: recorrido recursivo del árbol y lógica de evaluación de valores
- Matriz comparativa de los métodos de limpieza de JSON según el caso (Comparison Table)
- Los 5 errores fatales que se cometen con más frecuencia
- Flujo de trabajo de nivel producción en 5 pasos para aumentar la productividad real
- 7 consejos para limpiar payloads JSON
- Árbol de decisión final: ¿qué estrategia y qué herramienta deberías elegir?
- Diccionario de términos clave (Terminology Cheatsheet)
- Preguntas frecuentes
Para filtrar de una vez los null, las cadenas vacías (""), los arrays vacíos ([]) y los objetos vacíos ({}) que se mezclan en las respuestas de una API o en los archivos de configuración, al final basta con conocer una sola regla de decisión: qué valores se consideran «vacíos» y que ese criterio se aplica desde los valores internos hacia los externos. Este artículo explica esa regla tal cual, tomando el código como referencia.
Resumen ① Solo se eliminan las cadenas vacías,
null,undefined, los arrays vacíos y los objetos vacíos; el 0, elfalsey las cadenas no vacías se quedan tal cual. ② Como primero se limpian los valores hijos y después se evalúa el padre, si un objeto anidado queda vacío también se elimina en el nivel superior. ③ Como se usa elJSON.parseestándar, si hay comas finales, claves sin comillas o el literalundefined, el procesamiento se rechaza de entrada.
Por qué acabas necesitando esta limpieza
Hay casos en los que guardas la respuesta JSON de una API en un archivo para reutilizarla en la siguiente ejecución, o en los que reúnes los resultados de varias peticiones y los dejas como registro. En esas situaciones, si un campo opcional está vacío, la respuesta llega con un null, una cadena vacía o un array vacío ocupando ese lugar.
A medida que se acumulan archivos, puede pasar que haya más claves vacías que claves con valores reales. Cuando comparas esos archivos con un diff o los revisas a simple vista, si los valores vacíos llenan la pantalla cuesta encontrar el valor que de verdad necesitas ver.
El problema es que los valores vacíos no están solo en el nivel superior. Es habitual que estén anidados dentro de un objeto anidado, o dentro de un objeto que va a su vez dentro de un array, así que si los borras a mano nivel por nivel acabas saltándote algún punto y la estructura se rompe con facilidad.
Cómo hacerlo por tu cuenta sin ninguna herramienta
Esta regla de limpieza no tiene nada de especial: se puede expresar con una sola función recursiva. Si la pegas tal cual en la consola de las herramientas de desarrollo del navegador, obtienes el mismo resultado sin necesidad de ninguna herramienta.
function isEmpty(v) {
if (v === "" || v === null || v === undefined) return true;
if (Array.isArray(v) && v.length === 0) return true;
if (v && typeof v === "object" && Object.keys(v).length === 0) return true;
return false;
}
function cleanValues(value) {
if (Array.isArray(value)) {
return value.map(cleanValues).filter((v) => !isEmpty(v));
}
if (value !== null && typeof value === "object") {
const result = {};
for (const [key, val] of Object.entries(value)) {
const cleaned = cleanValues(val);
if (!isEmpty(cleaned)) result[key] = cleaned;
}
return result;
}
return value;
}
const data = JSON.parse(원본_JSON_문자열);
console.log(JSON.stringify(cleanValues(data), null, 2));
Si lo ordenamos paso a paso, queda así.
- Se parsea la cadena JSON original con
JSON.parse. Si la sintaxis es incorrecta, el error aparece en este paso, así que primero hay que comprobar que no haya errores de sintaxis. - Si es un array, se limpia primero cada elemento de forma recursiva y después se descartan solo los elementos cuyo resultado ya limpio sea una cadena vacía,
null,undefined, un array vacío o un objeto vacío. - Si es un objeto, se limpia primero de forma recursiva el valor de cada propiedad y, si el valor ya limpio está vacío según el mismo criterio, esa clave se saca del objeto resultante.
- Los valores que no son ni array ni objeto (cadenas, números, booleanos) pasan tal cual. El 0 y el
falseno encajan en ninguno de estos criterios, así que se quedan como están.
Compruébalo con nuestra herramienta gratuita: Limpiador de Valores Vacíos en JSON.
Sin registro ni instalación: pega tu JSON y los valores vacíos se limpian al instante.

Los puntos que más confunden
El criterio no es algo tan vago como «un valor que parece vacío»: solo se eliminan los valores que coinciden exactamente con una lista definida. Lo tienes resumido en la tabla siguiente.
| Valor | Resultado |
|---|---|
| "" (cadena vacía) | Se elimina |
| null | Se elimina |
| undefined | Se elimina |
| [] (array vacío) | Se elimina |
| {} (objeto vacío) | Se elimina |
| 0 | Se conserva |
| false | Se conserva |
| " " (un solo espacio) | Se conserva (no es una cadena vacía) |
| "0" (cadena) | Se conserva |
El motivo de que el 0 y el false se queden es que la función de decisión compara los valores exactamente con cinco cosas: "", null, undefined, un array vacío y un objeto vacío. Ni el 0 ni el false están entre esas cinco, así que pasan el filtro sin problema.
Con un solo espacio (" ") pasa lo mismo. Una cadena vacía ("") y una cadena que contiene un carácter son valores distintos, así que una cadena formada solo por espacios no se elimina y se queda tal cual.
Si no aparece ninguna salida y solo ves un mensaje de error en rojo, eso no tiene nada que ver con la regla de limpieza: lo que pasa es que la entrada en sí no es JSON válido. Estas son las causas más habituales.
- Una coma que sobra detrás del último elemento (coma final):
{"a": 1,} - Claves sin comillas:
{a: 1} - Usar directamente el literal
undefinedcomo valor:{"a": undefined}— en JSON no existe el valorundefined; solonulles válido - Cadenas o claves entre comillas simples:
{'a': 'b'}
JSON.parse sigue un estándar más estricto que los literales de objeto de JavaScript. Si aparece cualquiera de estos casos, el proceso se detiene en la fase de parseo y salta un error, y la lógica que filtra los valores vacíos ni siquiera llega a ejecutarse.
En resumen
- Se eliminan exactamente cinco cosas: las cadenas vacías,
null,undefined, los arrays vacíos y los objetos vacíos. - El 0, el
falsey las cadenas, arrays y objetos no vacíos (incluidos los que contienen espacios) se quedan tal cual. - La limpieza va de los valores hijos a los padres, así que si al vaciarse los hijos el padre se queda como un objeto vacío, el padre también se elimina en el paso siguiente.
- La entrada se valida con el
JSON.parseestándar, así que si hay una coma final, claves sin comillas o el literalundefined, el error aparece antes de la limpieza.
Sin registro ni instalación: pega tu JSON y los valores vacíos se limpian al instante.
Mecanismos técnicos clave: recorrido recursivo del árbol y lógica de evaluación de valores
Un simple reemplazo de cadenas (Replace) o una expresión regular (Regex) no basta para eliminar por completo los valores vacíos de un JSON anidado cuya profundidad es impredecible. La razón es que los datos JSON forman por naturaleza una estructura de árbol (Tree). Veamos en profundidad el algoritmo interno con el que trabaja el limpiador de valores vacíos en JSON, su complejidad matemática y las restricciones que impone el estándar.
1. Algoritmos de recorrido del árbol (Tree Traversal Algorithms)
Al depurar datos JSON, el concepto más importante es el recorrido recursivo en postorden ascendente (Bottom-up Post-order Traversal).
- Por qué es imprescindible el recorrido ascendente en postorden (Bottom-Up): consiste en evaluar y procesar primero los nodos hijos y, a partir de ese resultado, evaluar el nodo padre. Se ejecuta en el orden 'cleanValues(child) -> isEmpty(cleanedChild)'. Si tienes un dato como '{"parent": {"child": {"grandchild": ""}}}', el 'grandchild' más interno es una cadena vacía y se elimina. Entonces el objeto 'child' pasa a ser el objeto vacío '{}'. Ahora, al evaluar 'child', resulta ser un objeto vacío y se elimina otra vez. Al final, 'parent' también queda como objeto vacío y toda la cáscara se borra por completo.
- Los límites del recorrido descendente en preorden (Pre-order Traversal): es el enfoque que evalúa primero al padre. En el ejemplo anterior, al inspeccionar 'parent' o 'child' al principio, dentro existen claves, así que se concluye erróneamente que "no están vacíos". Cuando más tarde se borran los valores de los hijos, el padre queda como objeto vacío, pero su evaluación ya terminó, de modo que se produce un defecto fatal: quedan objetos cáscara vacíos y sin sentido.
2. Lógica precisa de identificación de valores (Value Discrimination Logic)
No debes borrar todo lo que sea falsy: hay que seleccionar únicamente los «valores vacíos que de verdad no significan nada» y que no afectan a la lógica de negocio de la aplicación.
- Valores que se podan (Pruned values):
- '""' (cadena vacía)
- 'null'
- 'undefined' (puede aparecer al manipular objetos internos después de parsear el JSON)
- '[]' (matriz vacía, sin ningún elemento)
- '{}' (objeto vacío, sin ninguna clave)
- Valores que debes conservar obligatoriamente (Preserved falsy primitives):
- '0' (el número 0 es un dato muy importante: saldos bancarios, cantidades, índices, etc.)
- 'false' (el booleano false indica estados claros como sin permiso, desactivado o no pagado)
- '" "' (una cadena con un espacio puede ser una entrada de espaciado intencionada)
3. Complejidad temporal y espacial (Time & Space Complexity)
- Complejidad temporal: O(N) — donde N es el número total de nodos (pares de clave y valor) del árbol JSON. Como cada nodo se recorre y se inspecciona exactamente una vez, el tiempo crece de forma lineal en proporción al tamaño de los datos.
- Complejidad espacial: O(D) — donde D es la profundidad máxima de anidamiento (Maximum Nesting Depth) del árbol. Cada vez que se llama a la función recursiva se acumula un frame en la pila de llamadas, así que un JSON con una profundidad muy grande puede provocar un desbordamiento de la pila de llamadas. Ahora bien, la profundidad de una respuesta de API habitual no supera los 10 niveles, por lo que en la práctica resulta muy seguro y rápido.
4. Restricciones del estándar JSON RFC 8259
En la primera línea de este algoritmo de depuración debe situarse siempre 'JSON.parse()'. El estándar RFC 8259 exige una sintaxis muy estricta para garantizar la integridad del intercambio de datos. Estos son los elementos que JavaScript permite pero que el JSON estándar nunca admite (provocan SyntaxError):
- La coma que se coloca después de la última propiedad de una matriz u objeto (Trailing commas)
- Las comillas simples (') que envuelven cadenas o claves de objeto
- Las claves de objeto escritas sin comillas
- Los literales numéricos especiales como 'NaN', 'Infinity', '-Infinity'
- El uso directo de la palabra clave 'undefined'
Por eso, para una limpieza perfecta siempre debe ir antes un paso en el que se reciba una cadena serializada conforme al estándar y se parsee.
Matriz comparativa de los métodos de limpieza de JSON según el caso (Comparison Table)
Estas son, de un vistazo, las ventajas, las desventajas y el alcance de cada método para eliminar valores vacíos en JSON según el entorno y la librería.
| Criterio de comparación | JS recursivo puro (recomendado) | JSON.stringify(obj, replacer) | Lodash (_.omitBy / _.pickBy) | Filtro de shell jq (entorno CLI) |
|---|---|---|---|---|
| Cómo funciona | Algoritmo recursivo en postorden perfecto | Filtrado durante el proceso de serialización | Filtrado superficial de propiedades de objeto | Recorrido del árbol con la función 'walk' |
| Eliminación de padres vacíos anidados | ✅ Soporte total (Bottom-Up) | ❌ Imposible (límite del enfoque Top-Down) | ❌ Imposible (solo se aplica a 1 nivel de profundidad) | ✅ Soporte total (recursión de la función walk) |
| Conservación de 0 y false | ✅ Soporte total (comprobación explícita de tipos) | ✅ Compatible (se puede tratar de forma condicional) | ⚠️ Requiere cuidado (se pierden al usar _.identity) | ✅ Soporte total ('!= null') |
| Tratamiento de elementos vacíos en matrices | ✅ Se filtran y se compactan por completo | ⚠️ Se sustituyen por 'null' (se mantiene la longitud de la matriz) | ❌ No se puede aplicar a elementos de matriz | ✅ Posible con 'map' y 'select' |
| Velocidad y rendimiento | Muy rápido (O(N), búsqueda lineal) | Rápido (optimizado por el motor nativo en C++) | Algo lento (sobrecarga de la librería) | Rápido (binario compilado en C) |
| Entorno de uso adecuado | Frontend de navegador, backend Node.js | Formateo de logs, datos simples de una dimensión | Proyectos que ya usan Lodash como dependencia | Acceso SSH a servidores, automatización con scripts de Bash |
Como se ve en la tabla, la función 'replacer', el segundo argumento de 'JSON.stringify', trabaja de arriba abajo, así que no puede detectar ni borrar un objeto padre que se ha quedado vacío porque sus hijos fueron eliminados; y si borras un elemento de una matriz, en lugar de desaparecer del todo, su sitio se rellena con 'null'. Por eso el enfoque del JS recursivo puro (Pure Recursive JS) es abrumadoramente superior en términos de integridad de datos.
Los 5 errores fatales que se cometen con más frecuencia
Incluso desarrolladores senior con mucha experiencia pasan por alto casos límite y cometen errores que causan un gran daño al servicio.
- Abusar de una simple comprobación truthy/falsy ('if (!value)') Si confías en la conversión de tipos flexible de JavaScript y validas con 'if (!value)', el número '0' de la base de datos (por ejemplo, un saldo de 0 won) y el valor 'false' (por ejemplo, el rechazo del consentimiento para recibir marketing) desaparecen por completo y la lógica de negocio se derrumba.
- Objetos cáscara vacíos que quedan por filtrar de arriba abajo (Top-Down) Si escribes la lógica revisando primero el objeto padre, no podrás tratar los nuevos objetos padre vacíos ('{ "user": {} }') que se generan al borrar los valores vacíos de los nodos hijos, y fracasarás en la optimización del tamaño del payload.
- Modificar el objeto original (In-place Mutation) y provocar efectos secundarios (Side Effect) Si usas 'delete obj[key]' dentro de la función recursiva para alterar directamente el objeto original, cuando otro módulo de la aplicación mantenga una referencia a ese objeto aparecerán errores inesperados de referencia en memoria y bugs de inconsistencia de estado. Mantén siempre la inmutabilidad (Immutability) devolviendo un objeto nuevo.
- Falta de lógica de defensa frente a referencias circulares (Circular Reference) Si metes en la función de limpieza una estructura en la que el objeto A referencia al objeto B y B vuelve a referenciar a A (por ejemplo, modelos ORM bidireccionales), la función repetirá la recursión sin detenerse nunca hasta lanzar el error 'Maximum call stack size exceeded' y tumbar todo el servidor Node.js.
- Ejecutar 'JSON.parse()' sin protección y sin manejo de excepciones Si introduces texto que llega de fuera en 'JSON.parse()' sin validarlo y se produce un error de sintaxis (Syntax Error), la aplicación se cae. Envuelve siempre la llamada en un bloque 'try-catch' o usa una función envoltorio segura.
Flujo de trabajo de nivel producción en 5 pasos para aumentar la productividad real
Más allá de una limpieza simple, este es un pipeline sistemático de cinco etapas para procesar y almacenar JSON de forma segura en entornos empresariales.
- Paso 1: Validación previa de esquema y sintaxis (Syntax Validation) Primero intenta parsear con 'try-catch' la cadena de datos que llega para comprobar que cumple la especificación RFC 8259 y, si hace falta, usa un validador de esquemas como Ajv o Zod para levantar una primera línea de defensa que confirme que la estructura básica de los datos coincide con lo esperado.
- Paso 2: Ejecutar la poda recursiva ascendente (Bottom-Up Pruning) Llama a una función recursiva como 'cleanValues' del cuerpo del artículo para eliminar por completo, empezando por los niveles más profundos, los nodos 'null', '""', '[]' y '{}' que no aportan nada.
- Paso 3: Verificación cruzada de integridad para conservar los datos falsy críticos ('0', 'false') Comprueba mediante pruebas unitarias (Unit Test) que los valores 0 o false críticos para el negocio no se hayan perdido en el objeto limpio. Este paso no debe omitirse, sobre todo en payloads financieros o de autenticación.
- Paso 4: Serialización optimizada según el entorno (Serialization) Convierte el objeto JavaScript puro ya limpio en una cadena según el objetivo de envío o de almacenamiento. Si es para transmitir por la red en producción, aplica 'JSON.stringify(cleaned, null, 0)' sin espacios; si alguien tiene que leer los logs con sus propios ojos, usa 'JSON.stringify(cleaned, null, 2)' para ganar legibilidad.
- Paso 5: Almacenamiento permanente y despliegue seguro hacia las API posteriores Carga el payload JSON ya aligerado, sin ningún residuo, en PostgreSQL o MongoDB, o envíalo de forma segura como respuesta de la API al cliente o al servidor.
7 consejos para limpiar payloads JSON
Técnicas avanzadas de desarrolladores senior para exprimir el rendimiento al milisegundo (ms) en sistemas que soportan tráfico masivo.
- Eliminar por completo la indentación (sangría) en los envíos de API de producción (Production): Si el objetivo no es depurar, aplica una serialización compacta que borre todos los saltos de línea (' ') y los espacios innecesarios al generar la respuesta de la API. En JSON de gran tamaño, los caracteres en blanco a veces ocupan más del 20% del total.
- Aplicar un strip de null justo antes de enviar respuestas GraphQL y REST: Los campos 'null' de relleno que impone el esquema solo consumen ancho de banda. Aplica la función de limpieza de forma común en el middleware o en el interceptor (Interceptor) del framework para reducir al mínimo el tamaño de la respuesta.
- Adoptar herramientas de serialización basadas en esquemas en la comunicación entre microservicios: Si trabajas en Node.js, introducir una librería basada en compilación previa de esquemas como 'fast-json-stringify' en lugar del 'JSON.stringify' nativo para la comunicación interna entre servicios reduce drásticamente la sobrecarga de cálculo de CPU.
- Sanear (Sanitize) siempre el payload de un webhook (Webhook) antes de guardarlo en la base de datos: Si metes tal cual un webhook enorme que envían una pasarela de pago externa o la API de un socio en una columna JSON de un RDBMS, los costes de almacenamiento se disparan. Carga únicamente los datos esenciales que quedan tras la limpieza.
- Evitar y detectar referencias circulares (Circular Reference) con WeakSet: Al convertir a JSON o limpiar objetos complejos en memoria, para evitar que reviente la pila de llamadas debes incluir código defensivo que guarde el objeto actual en un 'WeakSet' al entrar en la función recursiva y compruebe si ya se ha visitado.
- Controlar el momento de serialización de los objetos Date ISO 8601: Para que la función de limpieza de valores vacíos no confunda un objeto 'Date' de JavaScript con un objeto vacío '{}' y lo borre, añade un tratamiento de excepción 'value instanceof Date' dentro de la rama 'typeof value === "object"' o serialízalo a cadena antes de limpiar.
- Probar casos límite y datos complejos con esta herramienta web: Antes de aplicar directamente al código miles de líneas de JSON enrevesado, acostúmbrate a pegarlas en la herramienta de limpieza de esta página y comprobar a ojo que los '0', los 'false' y los objetos dentro de arrays se mantienen tal como esperas.
Árbol de decisión final: ¿qué estrategia y qué herramienta deberías elegir?
Te ayudamos a decidir en un segundo la mejor forma de eliminar valores vacíos según tu entorno de desarrollo y tus requisitos.
- Situación A (entorno de shell, pipelines CI/CD, análisis de logs de DevOps) ➔ Usar el filtro 'walk' del comando 'jq': En un entorno CLI, la máxima eficiencia se consigue sin abrir el navegador, pasando los datos por una tubería ('|') y ejecutando al instante un script de limpieza como 'walk(if type == "object" then ...)'.
- Situación B (archivos de configuración planos y sencillos, datos sin anidamiento profundo) ➔ Usar '_.omitBy' de 'lodash' o una función replacer de 'JSON.stringify': Si el objeto es plano y no necesita recursión profunda, lo sensato es aprovechar la librería de utilidades que ya tengas montada en el proyecto o las funciones nativas para reducir el código repetitivo.
- Situación C (estructuras profundamente anidadas, compresión de respuestas de API, datos financieros donde la integridad lo es todo) ➔ Implementar la función recursiva de abajo hacia arriba (Bottom-Up Recursive) 'cleanValues' presentada en el artículo: Cuando hay que extirpar hasta los objetos vacíos que están dentro de otros objetos y conservar '0' y 'false' es la prioridad absoluta, la lógica recursiva personalizada es la única respuesta válida.
- Situación D (limpieza puntual e inmediata de datos sin programar y con una visualización impecable) ➔ Usar el Limpiador de Valores Vacíos en JSON de este sitio web: La elección más perfecta cuando no tienes tiempo ni para instalar una librería y necesitas ya datos JSON limpios para meterlos en Excel o en un informe.
Diccionario de términos clave (Terminology Cheatsheet)
Seis palabras clave para no perderte en el complejo ecosistema de la ingeniería de datos.
- Recorrido postorden ascendente (Bottom-up Post-order Traversal): algoritmo de recorrido de árbol que procesa primero los nodos hijos más profundos y va evaluando de forma progresiva los nodos padres. Es el principio clave para eliminar objetos vacíos anidados.
- Valor falsy (Falsy Value): valor que en JavaScript se evalúa como 'false' cuando aparece en un contexto booleano. ('false', '0', '-0', '0n', '""', 'null', 'undefined', 'NaN')
- RFC 8259: especificación del estándar oficial más reciente del IETF para el formato JavaScript Object Notation (JSON), base del intercambio de datos de internet en todo el mundo.
- Replacer de JSON.stringify (Replacer): función callback o array que se pasa como segundo argumento para filtrar o transformar determinadas propiedades al convertir un objeto JavaScript en una cadena JSON.
- Referencia circular (Circular Reference): estado en el que un objeto se apunta a sí mismo de forma directa o indirecta. Si serializas a JSON o ejecutas una función recursiva en este estado, entras en un bucle infinito y se produce un error fatal.
- Optimización de payload (Payload Optimization): trabajo de eliminar los espacios innecesarios y las claves de relleno sin sentido del bloque de datos (payload) que cliente y servidor intercambian por la red, mejorando de forma notable la velocidad y el coste de la transmisión.
Preguntas frecuentes
Tres preguntas en profundidad, con sus respuestas, para ir más allá de la curiosidad y entender cómo funciona esto por dentro.
Q1. ¿Por qué no hay que eliminar "0" ni "false", y cómo se manejan como excepción?
A1. En la comunicación con APIs, el 0 es un dato con un significado esencial para la lógica de negocio: un descuento del 0 %, un saldo de 0 won, el índice 0 de un array, etc. "false" también indica un fallo de autenticación o una función desactivada. Si los eliminas, el sistema puede interpretarlos erróneamente como null o undefined, que significan "todavía no se han recogido los datos", y provocar errores como pagos que no se registran o saltos de permisos. Para evitarlo, la función de comprobación (isEmpty) no debe usar un operador de negación amplio como 'if (!value)', sino señalar de forma explícita los casos que hay que eliminar con 'v === "" || v === null || v === undefined' (igualdad estricta), de modo que se evite la coerción de tipos.
Q2. Tengo un objeto padre anidado a 5 niveles y, al borrar los valores vacíos del hijo del final, también se vaciaron todos los padres. ¿Cómo los elimino todos de una vez?
A2. Hay que recorrer la estructura de abajo hacia arriba (Bottom-Up), no de arriba abajo (Top-Down). El replacer nativo de JavaScript va de arriba abajo, así que no detecta que un objeto padre por el que ya pasó se queda vacío después. En cambio, la función 'cleanValues' del artículo solo decide si asignar el valor a la clave del padre cuando ya tiene el valor devuelto por la llamada recursiva ('if (!isEmpty(cleaned)) result[key] = cleaned;'). Es decir, si el hijo del final desaparece y el padre se queda como '{}', el isEmpty del nivel del abuelo que lo envuelve lo detecta al instante y lo elimina.
Q3. ¿Se puede hacer un filtrado recursivo igual de perfecto con el comando 'jq' en un entorno de shell Bash?
A3. ¡Sí, es perfectamente posible! Basta con usar 'walk', una función integrada que está disponible desde la versión 1.5 de 'jq'. 'walk' realiza internamente un recorrido en postorden (Post-order Traversal) perfecto. Escribe lo siguiente en el shell: 'jq 'walk(if type == "object" then with_entries(select(.value != null and .value != "" and .value != [] and .value != {})) else . end)' input.json' Con este potente comando de una sola línea puedes comprimir a la perfección, en un instante, incluso archivos de volcado de varios gigabytes generados por el monitoreo de servidores Linux o por tareas de cron (Cron).
Este artículo está adaptado de nuestro original en coreano. Leer el original en coreano