Fusionar JSON

#1Entrada
#2Entrada

Herramienta online gratuita para fusionar JSON. Con un clic fusiona múltiples objetos JSON según una estrategia elegida (Profunda / Superficial / Concatenar Array / Reemplazar Array) con 4 modos de resolución de conflictos. Ideal para agregación multi-fuente, capas de configuración y consolidación i18n.

Relacionado

¿Qué es Fusionar JSON (JSON Merge)?

Fusionar JSON (JSON Merge) es la operación de combinar dos o más objetos JSON en un nuevo objeto según ciertas reglas. Aparece extremadamente frecuentemente en ingeniería: ① Ensamblar JSON de múltiples microservicios en una respuesta unificada (agregación de capa BFF); ② Combinar config base / env / usuario bajo una lógica de "override por entorno" para producir la config final (Node.js config, Viper, Spring Cloud Config); ③ Fusionar, sobrescribir y complementar múltiples archivos de traducción i18n en un diccionario completo; ④ Combinar múltiples arrays de datos mock en datos de prueba completos; ⑤ Fusionar múltiples respuestas paginadas de API en un dataset completo.

La parte difícil no es la "fusión" sino "cómo manejar conflictos". Hay 4 estrategias comunes de resolución de conflictos: ① **Fusión Profunda (Deep Merge)**: Recurre a objetos anidados, fusionando cada clave individualmente y sobrescribiendo sólo cuando hay conflicto en nodos hoja — ideal para capas de configuración. ② **Fusión Superficial (Shallow Merge)**: Sólo fusiona claves de nivel superior, reemplazando claves del mismo nombre en su totalidad — semántica más simple, similar a `Object.assign`. ③ **Concatenar Array (Array Concat)**: Concatena valores de array en un array largo preservando el orden de los elementos — ideal para agregación de API. ④ **Reemplazar Array (Array Replace)**: Reemplaza valores de array en su totalidad con la entrada posterior — ideal para override de configuración.

A nivel de implementación, la fusión profunda suele usar recursión basada en pila: primero verifica que ambos lados sean objetos planos (no arrays, no null), luego procesa recursivamente cada clave; cuando los tipos son inconsistentes (ej. un lado es objeto, el otro array para el mismo nombre), generalmente sigue la regla "la última entrada gana" sin conversión de tipos. La herramienta Fusionar JSON de GeekFormat incluye las 4 estrategias anteriores y te permite cambiar directamente en la página; puedes pegar 2 a N segmentos JSON a la vez, auto-fusionar en orden, y emitir un resultado uniformemente formateado. Todo el proceso de fusión ocurre localmente en el navegador, los datos originales no se suben.

Casos de uso

  • Fusiona múltiples respuestas API de microservicios en una estructura JSON unificada para el front-end
  • Agrega archivos de configuración por capas base / dev / prod en la config final vía override por entorno
  • Fusiona múltiples archivos de traducción i18n por idioma, deduplica y completa en un diccionario completo
  • Combina múltiples arrays de datos mock o respuestas API paginadas en un dataset completo
  • Componente front-end fusionando config por defecto + personalización de usuario + config de experimento A/B remoto
  • Durante migración de datos, fusiona múltiples exportaciones JSON de sistemas fuente en un formato aguas abajo unificado

Cómo Usar

  1. Pega 2 a N segmentos JSON a fusionar en las cajas de entrada izquierdas (2 por defecto), o haz clic en "+" para añadir más entradas
  2. Selecciona una estrategia de fusión del desplegable de la barra de herramientas: Fusión Profunda / Fusión Superficial / Concatenar Array / Reemplazar Array
  3. Haz clic en el botón "Fusionar"; la caja de salida derecha muestra el resultado formateado. Si la entrada tiene errores de sintaxis, se muestran el número de línea específico y el mensaje de error
  4. Tras confirmar el resultado, haz clic en "Copiar" para poner la salida fusionada en el portapapeles, o haz clic en "Descargar" para guardar como merged.json para más formateo, validación Schema, etc.

Características

  • 4 estrategias de fusión: Fusión Profunda / Fusión Superficial / Concatenar Array / Reemplazar Array, conmutable con un clic para adaptarse a diferentes escenarios de negocio
  • Soporta 2 a N segmentos JSON: 2 cajas de entrada por defecto, haz clic en "+" para añadir dinámicamente más JSON fuente, flexible para agregación multi-fuente
  • Fusión recursiva profunda: maneja inteligentemente objetos anidados multi-nivel, resuelve conflictos de hoja según la estrategia especificada, preservando todos los campos válidos
  • Resolución de conflictos flexible: conflictos de nivel superior siguen la estrategia seleccionada; conflictos de objetos anidados van profundo; conflictos de array se diferencian vía arrayConcat/arrayReplace
  • Salida formateada unificada: los resultados se muestran con sangría de 2 espacios para fácil revisión humana y copia directa a herramientas aguas abajo
  • Ejecución en tiempo real: haz clic en "Fusionar" justo después de pegar para obtener resultados; los errores muestran números de línea JSON específicos y mensajes de error
  • Procesamiento local para privacidad: análisis, fusión y formateo ocurren localmente en el navegador, no se envía entrada a ningún servidor
  • Conexión fluida con herramientas aguas abajo: los resultados pueden copiarse con un clic a Formatear JSON, Validación Schema, generadores de código, etc.

Ejemplos de Código

Fusión profunda en JavaScript con lodash.merge

javascript
// npm install lodash.merge
import merge from 'lodash.merge';

const a = { user: { name: 'Alice', age: 28 }, tags: ['admin'] };
const b = { user: { email: 'a@x.com', age: 29 }, tags: ['editor'] };

// Fusión profunda: objetos anidados se fusionan recursivamente, los nodos hoja toman el valor posterior
const deep = merge({}, a, b);
console.log(deep);
// => { user: { name: 'Alice', age: 29, email: 'a@x.com' }, tags: ['admin', 'editor'] }

// Fusión superficial: las claves de nivel superior se reemplazan totalmente, sin descender al anidamiento
const shallow = Object.assign({}, a, b);
console.log(shallow);
// => { user: { email: 'a@x.com', age: 29 }, tags: ['editor'] }

Fusión profunda en Python con mergedeep

python
# pip install mergedeep
from mergedeep import merge

a = {"user": {"name": "Alice", "age": 28}, "tags": ["admin"]}
b = {"user": {"email": "a@x.com", "age": 29}, "tags": ["editor"]}

# Fusión profunda
result = merge(a, b)
print(result)
# => {'user': {'name': 'Alice', 'age': 29, 'email': 'a@x.com'}, 'tags': ['admin', 'editor']}

# Nota: mergedeep por defecto concatena arrays; string/number sobrescribe.
# Para sobrescritura de array, añade strategy='override'

Fusión multi-JSON en CLI con jq -s

bash
# Fusiona múltiples arrays JSON en un array largo
jq -s 'add' a.json b.json c.json

# Fusiona recursivamente múltiples objetos JSON (jq 1.6+)
jq -s 'reduce .[] as $item ({}; . * $item)' a.json b.json

# Fusión superficial: superpone las claves de nivel superior de b sobre a
jq -s '.[0] * .[1]' a.json b.json

# Fusiona arrays y mantiene sólo los campos id deduplicados
jq -s '[.[].items[]] | unique_by(.id)' a.json b.json

Preguntas Frecuentes

¿Fusionar JSON y Concatenar JSON son lo mismo?

No exactamente. "Concatenar" usualmente significa empalmar cadenas directamente sin estructura; "fusionar" significa combinar recursivamente múltiples objetos por estructura JSON y manejar conflictos de nombres de claves. Esta herramienta se refiere a lo segundo — fusión estructurada de JSON.

¿Cómo elijo entre Fusión Profunda y Fusión Superficial?

Fusión superficial: sólo maneja claves de nivel superior, las claves del mismo nombre se reemplazan en su totalidad, similar a `Object.assign` — lo más simple. Fusión profunda: recurre a objetos anidados, fusionando en cada nodo hoja — más inteligente. Si tus múltiples JSONs añaden campos en diferentes sub-rutas (ej. base.user.name y override.user.email), usa fusión profunda. Si quieres reemplazar un sub-objeto entero de una vez, usa fusión superficial.

Al fusionar arrays, ¿es por orden o por índice?

Por defecto, esta herramienta sigue la semántica de "concat": combina múltiples arrays en un array largo preservando el orden de los elementos. Si tus dos arrays tienen la misma longitud y quieres sobrescritura por índice, cambia a "arrayReplace" y envuelve manualmente el array en una estructura de objeto primero.

¿Cómo se decide el ganador del conflicto cuando los nombres de claves colisionan?

Se decide por orden de entrada: el JSON posterior sobrescribe las claves del mismo nombre anteriores (sobrescritura total bajo estrategias Superficial / Reemplazar Array, sólo sobrescritura de hoja bajo Fusión Profunda). Si quieres "la entrada anterior gana", invierte el orden de entrada.

¿Puede fusionar arrays JSON?

Sí. Dos escenarios típicos: ① Múltiples JSONs son todos arrays → usa "arrayConcat" para fusionar en un array largo; ② Múltiples JSONs son objetos, pero un campo es un array → usa "arrayConcat" para fusionar los arrays, o usa "arrayReplace" para mantener el valor de la entrada posterior.

¿Puede fusionar más de 2 JSONs a la vez?

Sí. Por defecto hay 2 cajas de entrada; haz clic en "+" para añadir dinámicamente más. Todas las entradas se fusionan de arriba a abajo en orden. Teóricamente ilimitado, pero la memoria del navegador limita el tamaño de un solo segmento.

¿Cómo se determina el orden de las claves tras fusionar?

Fusión profunda: el orden de claves del primer JSON tiene prioridad; las claves nuevas de JSONs posteriores se añaden al final del nivel correspondiente. Fusión superficial: por orden de entrada — todas las claves del primer JSON aparecen primero, las claves nuevas de JSONs posteriores se añaden al nivel superior; las claves del mismo nombre mantienen el orden de la primera sin cambios.

¿La herramienta cambia tipos de campos?

No, no cambia tipos activamente. Si bajo estrategia Superficial / Reemplazar Array, las claves del mismo nombre en dos JSONs son de tipos diferentes (uno objeto, uno array), sigue "la última entrada gana" y sobrescribe directamente, sin conversión de tipo. La Fusión Profunda sólo recurre cuando ambos lados son objetos planos; en todos los demás casos sobrescribe.

¿Se preservan los valores null?

Sí. null es un valor JSON legal; esta herramienta trata null como un valor hoja normal: bajo Superficial / Reemplazar Array, un null posterior sobrescribe el valor anterior; bajo Fusión Profunda, un null se maneja por la regla de sobrescritura y no se salta especialmente.

¿La fusión emite estadísticas?

Sí. El área de resultados muestra el número de segmentos JSON y el conteo total de claves, para verificación rápida; consulta la salida formateada a la derecha para la lista completa de campos.

¿La herramienta subirá mi JSON a un servidor?

No. Análisis, fusión y formateo ocurren localmente en el navegador, la entrada y los resultados intermedios no se envían a ningún servidor. Funciona sin conexión, apta para JSON multi-fuente sensible (ej. configs de entornos de producción, respuestas API internas).

¿Cuál es el mejor orden de uso con Formatear JSON y Validación Schema?

Cadena recomendada: ① Reparar JSON (limpiar JSON ilegal) → ② Esta herramienta Fusionar JSON (fusión multi-fuente) → ③ Formatear JSON (unificar sangría) → ④ Validación JSON Schema (verificar estructura final) → ⑤ Generación de código (TypeScript / Java / Go etc.). Elige los pasos que necesites.

Solución de problemas

La fusión muestra "Unexpected token" o "Invalid JSON"

Causa: al menos una caja de entrada contiene JSON inválido. Solución: primero pega el JSON que falla en la herramienta Reparar JSON para limpiar (auto-maneja comas finales, comillas simples, claves sin comillas, etc.), luego vuelve a esta herramienta; o verifica si te faltaron llaves / corchetes externos.

Algunos campos no aparecen tras fusionar

Causa: bajo estrategia Superficial / Reemplazar Array, las claves del mismo nombre se sobrescriben totalmente por la entrada posterior; bajo Fusión Profunda, los campos con valor null también sobrescriben el objeto anterior. Solución: cambia la estrategia a "Fusión Profunda" para revisar capa por capa; si se confirma que es una sobrescritura null posterior, elimina el campo null del JSON posterior o reemplázalo con un valor placeholder.

El array fue reemplazado en vez de concatenado

Causa: la estrategia actual es "Fusión Superficial" o "Reemplazar Array". Solución: en el desplegable de la barra de herramientas, cambia a "Concatenar Array"; o combina manualmente los dos arrays en uno antes de fusionar.

Un objeto se convirtió en array (o viceversa) tras Fusión Profunda

Causa: los dos JSONs tienen tipos inconsistentes en la misma ruta ("objeto vs array"); la Fusión Profunda sigue "la última entrada gana" cuando los tipos difieren. Solución: unifica los tipos en ambos lados (ambos como objeto o ambos como array), o cambia a estrategia Superficial / Reemplazar Array para hacer la semántica explícita.

El orden de claves quedó desordenado tras la fusión

Causa: las claves nuevas del segundo JSON se añaden por posición de inserción tras el primer JSON; los navegadores / parsers auto-ordenan claves enteras puras numéricamente. Solución: primero pasa todos los JSONs de entrada por la herramienta JSON Sort para unificar el orden de nombres de claves, luego fusiona; o ordena de nuevo antes de usar el resultado.

Archivos grandes (10 MB+) hacen que la fusión se congele

Causa: analizar muchos textos grandes con JSON.parse de una vez占用 mucha memoria. Solución: mantén cada entrada dentro de 1-2 MB; para archivos enormes usa scripts Node.js (lodash.merge) o Python (mergedeep) localmente; usa esta herramienta para verificación pequeña después.

Glosario

JSON Merge
Operación de combinar dos o más objetos JSON en uno nuevo según reglas especificadas. El desafío central es la estrategia para resolver conflictos de nombres de claves.
Deep Merge
Estrategia que recurre a objetos anidados y fusiona en cada nodo hoja; sólo recurre cuando ambos lados son objetos planos, en caso contrario cae en sobrescritura.
Shallow Merge
Estrategia que sólo fusiona claves de nivel superior y reemplaza claves del mismo nombre en su totalidad; equivalente en JS a `Object.assign({}, a, b)`.
Array Concat
Una de las estrategias de fusión de arrays: combina múltiples arrays en un array largo preservando el orden de los elementos; usado a menudo para agregación de respuestas API.
Array Replace
Una de las estrategias de fusión de arrays: los arrays del mismo nombre se reemplazan en su totalidad con la entrada posterior; usado a menudo para override de configuración.
Object.assign
Método integrado de JavaScript que copia superficialmente todas las propiedades propias enumerables de uno o más objetos fuente a un objeto destino; la implementación estándar de facto de fusión superficial.
lodash.merge
Función de fusión profunda proporcionada por la librería Lodash; la implementación de deep merge más común en el ecosistema Node.js; los arrays se concatenan, no se sobrescriben.
mergedeep (Python)
Librería de fusión profunda en el ecosistema Python (pip install mergedeep); soporta un parámetro strategy para controlar el comportamiento concat vs replace de arrays.
jq -s 'add'
Comando jq que suma múltiples arrays JSON en uno; fusionar múltiples objetos JSON requiere `reduce .[] as $item ({}; . * $item)`.
BFF (Backend for Frontend)
Capa de agregación en arquitectura de microservicios ubicada entre el front-end y los servicios back-end; a menudo necesita fusionar respuestas JSON de múltiples servicios en una respuesta unificada — un escenario clásico de fusión JSON.

4 Estrategias de Fusión JSON Comparadas

EstrategiaAlcanceManejo de arrayEscenario típico
Fusión ProfundaRecurre a todos los niveles anidadosPor arrayConcat/arrayReplace seleccionadoCapas de config multi-entorno, fusión de diccionarios i18n
Fusión SuperficialSólo fusiona nivel superiorSobrescritura totalReemplazo simple estilo Object.assign
Concatenar ArrayNivel superiorConcatenado en nuevo arrayAgregación de API paginadas, fusión de datos mock
Reemplazar ArrayNivel superiorLa última entrada ganaOverride de config de Feature Flag

Implementaciones Comunes de Fusión JSON Comparadas

Implementación / libreríaLenguajeComportamiento por defectoNotas
Object.assignJavaScriptFusión superficialLib estándar ES2015; tras ES2017 puedes usar `Object.assign({}, a, b)`
{ ...a, ...b }JavaScriptFusión superficialOperador spread; sintaxis más concisa
lodash.mergeJavaScriptFusión profundaArrays se concatenan (sin sobrescritura); npm install lodash.merge
mergedeepPythonFusión profundastrategy='override' para cambiar concat de array a replace
deepmerge (Python)PythonFusión profundaOtra implementación popular; pip install deepmerge
jq -s 'add'ShellSuma de arraysFusión de objetos necesita `reduce .[] as $i ({}; . * $i)`

Authoritative References