Mesclar JSON

#1Entrada
#2Entrada

Ferramenta online gratuita para mesclar JSON. Com um clique, mescle múltiplos objetos JSON de acordo com uma estratégia escolhida (Profunda / Superficial / Concatenar Array / Substituir Array) com 4 modos de resolução de conflitos. Ideal para agregação multi-fonte, camadas de configuração e consolidação i18n.

Sugestões Relacionadas

O que é Mesclar JSON (JSON Merge)?

Mesclar JSON (JSON Merge) é a operação de combinar dois ou mais objetos JSON em um novo objeto de acordo com certas regras. Aparece com extrema frequência em engenharia: ① Montar JSON de vários microsserviços em uma resposta unificada (agregação de camada BFF); ② Combinar config base / env / usuário sob a lógica 'override por ambiente' para produzir a config final (Node.js config, Viper, Spring Cloud Config); ③ Mesclar, sobrescrever e complementar vários arquivos de tradução i18n em um dicionário completo; ④ Combinar vários arrays de dados mock em dados de teste completos; ⑤ Mesclar várias respostas paginadas de API em um dataset completo.

A parte difícil não é a 'fusão', mas 'como lidar com conflitos'. Existem 4 estratégias comuns de resolução de conflitos: ① **Deep Merge**: Recursão em objetos aninhados, mesclando cada chave individualmente e sobrescrevendo apenas em caso de conflito em nós folha - ideal para camadas de configuração. ② **Shallow Merge**: Mescla apenas chaves de nível superior, substituindo inteiramente chaves com o mesmo nome - semântica mais simples, similar a `Object.assign`. ③ **Concatenar Array**: Concatena valores de array em um array longo preservando a ordem dos elementos - ideal para agregação de API. ④ **Substituir Array**: Substitui inteiramente os valores de array com a entrada posterior - ideal para override de configuração.

No nível de implementação, o deep merge normalmente usa recursão baseada em pilha: primeiro verifica que ambos os lados são objetos simples (não arrays, não null), depois processa recursivamente cada chave; quando os tipos são inconsistentes (ex. um lado é um objeto, o outro é um array para o mesmo nome), geralmente segue a regra 'a última entrada vence' sem conversão de tipo. A ferramenta Mesclar JSON da GeekFormat inclui as 4 estratégias acima e permite alternar diretamente na página; você pode colar 2 a N segmentos JSON de uma vez, mesclar automaticamente em ordem, e produzir um resultado uniformemente formatado. O processo inteiro de fusão acontece localmente no navegador, os dados originais não são carregados.

Casos de uso

  • Mescle várias respostas API de microsserviços em uma estrutura JSON unificada para o front-end
  • Agregue arquivos de configuração em camadas base / dev / prod na config final via override por ambiente
  • Mescle vários arquivos de tradução i18n por idioma, deduplique e complete em um dicionário completo
  • Combine vários arrays de dados mock ou respostas API paginadas em um dataset completo
  • Componente front-end mesclando config padrão + personalização do usuário + config de experimento A/B remoto
  • Durante a migração de dados, mescle várias exportações JSON de sistemas fonte em um formato a jusante unificado

Como Usar

  1. Cole 2 a N segmentos JSON a serem mesclados nas caixas de entrada esquerdas (2 por padrão), ou clique em '+' para adicionar mais entradas
  2. Selecione uma estratégia de mesclagem no menu suspenso da barra de ferramentas: Deep Merge / Shallow Merge / Concatenar Array / Substituir Array
  3. Clique no botão 'Mesclar'; a caixa de saída direita mostra o resultado formatado. Se a entrada tem erros de sintaxe, o número da linha específico e a mensagem de erro são mostrados
  4. Após confirmar o resultado, clique em 'Copiar' para colocar a saída mesclada na área de transferência, ou clique em 'Baixar' para salvar como merged.json para mais formatação, validação Schema, etc.

Recursos

  • 4 estratégias de fusão: Deep Merge / Shallow Merge / Concatenar Array / Substituir Array, alternáveis com um clique para diferentes cenários de negócio
  • Suporta 2 a N segmentos JSON: 2 caixas de entrada por padrão, clique em '+' para adicionar dinamicamente mais JSON fonte, flexível para agregação multi-fonte
  • Fusão recursiva profunda: lida inteligentemente com objetos aninhados em múltiplos níveis, resolve conflitos de folha de acordo com a estratégia especificada, preservando todos os campos válidos
  • Resolução flexível de conflitos: conflitos de nível superior seguem a estratégia selecionada; conflitos de objetos aninhados vão fundo; conflitos de array se diferenciam via arrayConcat/arrayReplace
  • Saída uniformemente formatada: os resultados são mostrados com indentação de 2 espaços para fácil revisão humana e cópia direta para ferramentas a jusante
  • Execução em tempo real: clique em 'Mesclar' logo após colar para obter resultados; erros mostram números de linha JSON específicos e mensagens de erro
  • Processamento local para privacidade: análise, fusão e formatação acontecem localmente no navegador, nenhuma entrada enviada a um servidor
  • Transição suave para ferramentas a jusante: os resultados podem ser copiados com um clique para o Formatador JSON, Validador Schema, geradores de código, etc.

Exemplos de Código

Fusão profunda em JavaScript com 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'] };

// Fusão profunda: objetos aninhados são mesclados recursivamente, nós folha pegam o valor posterior
const deep = merge({}, a, b);
console.log(deep);
// => { user: { name: 'Alice', age: 29, email: 'a@x.com' }, tags: ['admin', 'editor'] }

// Fusão superficial: chaves de nível superior são substituídas inteiramente, sem descer no aninhamento
const shallow = Object.assign({}, a, b);
console.log(shallow);
// => { user: { email: 'a@x.com', age: 29 }, tags: ['editor'] }

Fusão profunda em Python com 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"]}

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

# Nota: mergedeep por padrão concatena arrays; string/number sobrescreve.
# Para sobrescrita de array, adicione strategy='override'

Mesclagem multi-JSON na CLI com jq -s

bash
# Mescla múltiplos arrays JSON em um array longo
jq -s 'add' a.json b.json c.json

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

# Fusão superficial: sobrepõe as chaves de nível superior de b em a
jq -s '.[0] * .[1]' a.json b.json

# Mescla arrays e mantém apenas os campos id deduplicados
jq -s '[.[].items[]] | unique_by(.id)' a.json b.json

Perguntas frequentes

Mesclar JSON e Concatenar JSON são a mesma coisa?

Não exatamente. 'Concatenar' geralmente significa unir strings diretamente sem estrutura; 'mesclar' significa combinar recursivamente múltiplos objetos por estrutura JSON e lidar com conflitos de nomes de chaves. Esta ferramenta se refere ao último - fusão estruturada de JSON.

Como escolho entre Deep Merge e Shallow Merge?

Shallow Merge: lida apenas com chaves de nível superior, chaves com o mesmo nome são substituídas inteiramente, similar a `Object.assign` - o mais simples. Deep Merge: recursa em objetos aninhados, mesclando em cada nó folha - mais inteligente. Se seus múltiplos JSONs adicionam campos em subcaminhos diferentes (ex. base.user.name e override.user.email), use deep merge. Se você quer substituir um sub-objeto inteiro de uma vez, use shallow merge.

Ao mesclar arrays, é por ordem ou por índice?

Por padrão, esta ferramenta segue a semântica 'concat': combina múltiplos arrays em um array longo preservando a ordem dos elementos. Se seus dois arrays têm o mesmo comprimento e você quer sobrescrita por índice, mude para 'arrayReplace' e envolva manualmente o array em uma estrutura de objeto primeiro.

Como o vencedor do conflito é decidido quando nomes de chaves colidem?

Decidido pela ordem de entrada: o JSON posterior sobrescreve as chaves com o mesmo nome anteriores (sobrescrita total sob Shallow / Substituir Array, apenas sobrescrita de folha sob Deep Merge). Se você quer 'a entrada anterior vence', inverta a ordem de entrada.

Pode mesclar arrays JSON?

Sim. Dois cenários típicos: ① Múltiplos JSONs são todos arrays → use 'arrayConcat' para mesclar em um array longo; ② Múltiplos JSONs são objetos, mas um campo é um array → use 'arrayConcat' para mesclar os arrays, ou 'arrayReplace' para manter o valor da entrada posterior.

Pode mesclar mais de 2 JSONs de uma vez?

Sim. Por padrão há 2 caixas de entrada; clique em '+' para adicionar dinamicamente mais. Todas as entradas são mescladas de cima para baixo em ordem. Teoricamente ilimitado, mas a memória do navegador limita o tamanho de um único segmento.

Como a ordem das chaves é determinada após a mesclagem?

Deep Merge: a ordem das chaves do primeiro JSON tem prioridade; novas chaves dos JSONs posteriores são adicionadas ao final do nível correspondente. Shallow Merge: por ordem de entrada - todas as chaves do primeiro JSON aparecem primeiro, novas chaves dos JSONs posteriores são adicionadas no nível superior; chaves com o mesmo nome mantêm a ordem da primeira inalterada.

A ferramenta modifica tipos de campos?

Não, ela não modifica ativamente tipos. Se sob estratégia Shallow / Substituir Array as chaves com o mesmo nome em dois JSONs são de tipos diferentes (um objeto, um array), segue 'a última entrada vence' e sobrescreve diretamente, sem conversão de tipo. Deep Merge recursa apenas quando ambos os lados são objetos simples; em todos os outros casos sobrescreve.

Valores null são preservados?

Sim. null é um valor JSON válido; esta ferramenta trata null como um valor folha normal: sob Shallow / Substituir Array, um null posterior sobrescreve o valor anterior; sob Deep Merge, um null é tratado pela regra de sobrescrita e não é pulado especialmente.

A fusão emite estatísticas?

Sim. A área de resultados mostra o número de segmentos JSON e a contagem total de chaves, para verificação rápida; consulte a saída formatada à direita para a lista completa de campos.

A ferramenta carrega meu JSON em um servidor?

Não. Análise, fusão e formatação acontecem localmente no navegador, entrada e resultados intermediários não são enviados a nenhum servidor. Funciona offline, adequado para JSON multi-fonte sensíveis (ex. configs de ambientes de produção, respostas API internas).

Qual é a melhor ordem de uso com Formatador JSON e Validador Schema?

Cadeia recomendada: ① Reparar JSON (limpar JSON ilegal) → ② Esta ferramenta Mesclar JSON (fusão multi-fonte) → ③ Formatar JSON (unificar indentação) → ④ Validação JSON Schema (verificar estrutura final) → ⑤ Geração de código (TypeScript / Java / Go etc.). Escolha os passos que precisar.

Solução de Problemas

A fusão mostra 'Unexpected token' ou 'Invalid JSON'

Causa: pelo menos uma caixa de entrada contém JSON inválido. Solução: primeiro cole o JSON que falhou na ferramenta Reparar JSON para limpar (trata automaticamente vírgulas finais, aspas simples, chaves sem aspas, etc.), depois volte para esta ferramenta; ou verifique se faltaram chaves/colchetes externos.

Alguns campos não aparecem após a mesclagem

Causa: sob estratégia Shallow / Substituir Array, chaves com o mesmo nome são totalmente sobrescritas pela entrada posterior; sob Deep Merge, campos com valor null também sobrescrevem o objeto anterior. Solução: mude a estratégia para 'Deep Merge' para verificar camada por camada; se confirmado que é uma sobrescrita null posterior, remova o campo null do JSON posterior ou substitua por um valor placeholder.

O array foi substituído em vez de concatenado

Causa: a estratégia atual é 'Shallow Merge' ou 'Substituir Array'. Solução: no menu suspenso da barra de ferramentas, mude para 'Concatenar Array'; ou combine manualmente os dois arrays em um antes de mesclar.

Um objeto virou um array (ou vice-versa) após Deep Merge

Causa: os dois JSONs têm tipos inconsistentes no mesmo caminho ('objeto vs array'); Deep Merge segue 'a última entrada vence' quando os tipos diferem. Solução: una os tipos em ambos os lados (ambos como objeto ou ambos como array), ou mude para estratégia Shallow / Substituir Array para tornar a semântica explícita.

A ordem das chaves está bagunçada após a mesclagem

Causa: as novas chaves do segundo JSON são adicionadas por posição de inserção após o primeiro JSON; navegadores/parsers ordenam automaticamente chaves inteiras puras numericamente. Solução: passe todos os JSONs de entrada pela ferramenta JSON Sort primeiro para unificar a ordem dos nomes das chaves, depois mescle; ou ordene novamente antes de usar o resultado.

Arquivos grandes (10 MB+) fazem a fusão congelar

Causa: analisar muitos textos grandes com JSON.parse de uma vez ocupa muita memória. Solução: mantenha cada entrada dentro de 1-2 MB; para arquivos enormes use scripts Node.js (lodash.merge) ou Python (mergedeep) localmente; use esta ferramenta para verificação pequena depois.

Glossário

JSON Merge
Operação de combinar dois ou mais objetos JSON em um novo de acordo com regras especificadas. O desafio central é a estratégia para resolver conflitos de nomes de chaves.
Deep Merge
Estratégia que recursa em objetos aninhados e mescla em cada nó folha; recursa apenas quando ambos os lados são objetos simples, caso contrário cai em sobrescrita.
Shallow Merge
Estratégia que mescla apenas chaves de nível superior e substitui inteiramente chaves com o mesmo nome; equivalente em JS a `Object.assign({}, a, b)`.
Array Concat
Uma das estratégias de mesclagem de array: combina múltiplos arrays em um array longo preservando a ordem dos elementos; frequentemente usado para agregação de respostas API.
Array Replace
Uma das estratégias de mesclagem de array: arrays com o mesmo nome são substituídos inteiramente pela entrada posterior; frequentemente usado para override de configuração.
Object.assign
Método embutido em JavaScript que copia superficialmente todas as propriedades próprias enumeráveis de um ou mais objetos fonte para um objeto destino; a implementação padrão de fato da fusão superficial.
lodash.merge
Função de deep merge fornecida pela biblioteca Lodash; a implementação de deep merge mais comum no ecossistema Node.js; arrays são concatenados, não sobrescritos.
mergedeep (Python)
Biblioteca de deep merge no ecossistema Python (pip install mergedeep); suporta um parâmetro strategy para controlar o comportamento de concat vs replace de arrays.
jq -s 'add'
Comando jq que soma múltiplos arrays JSON em um; mesclar múltiplos objetos JSON requer `reduce .[] as $item ({}; . * $item)`.
BFF (Backend for Frontend)
Camada de agregação na arquitetura de microsserviços localizada entre o front-end e os serviços back-end; frequentemente precisa mesclar as respostas JSON de múltiplos serviços em uma resposta unificada - um cenário clássico de fusão JSON.

4 Estratégias de Mesclagem JSON Comparadas

EstratégiaEscopoTratamento de arrayCenário típico
Deep MergeRecursa em todos os níveis aninhadosPor arrayConcat/arrayReplace selecionadoCamadas de config multi-ambiente, fusão de dicionários i18n
Shallow MergeMescla apenas o nível superiorSobrescrita totalSubstituição simples estilo Object.assign
Concatenar ArrayNível superiorConcatenado em novo arrayAgregação de API paginadas, fusão de dados mock
Substituir ArrayNível superiorA última entrada venceOverride de config de Feature Flag

Implementações Comuns de Mesclagem JSON Comparadas

Implementação / bibliotecaLinguagemComportamento padrãoNotas
Object.assignJavaScriptFusão superficialLib padrão ES2015; após ES2017 pode usar `Object.assign({}, a, b)`
{ ...a, ...b }JavaScriptFusão superficialOperador spread; sintaxe mais concisa
lodash.mergeJavaScriptFusão profundaArrays concatenados (sem sobrescrita); npm install lodash.merge
mergedeepPythonFusão profundastrategy='override' para mudar concat de array para replace
deepmerge (Python)PythonFusão profundaOutra implementação popular; pip install deepmerge
jq -s 'add'ShellSoma de arraysFusão de objetos requer `reduce .[] as $i ({}; . * $i)`

Authoritative References