Mesclar JSON
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
- 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
- Selecione uma estratégia de mesclagem no menu suspenso da barra de ferramentas: Deep Merge / Shallow Merge / Concatenar Array / Substituir Array
- 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
- 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.jsonPerguntas 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égia | Escopo | Tratamento de array | Cenário típico |
|---|---|---|---|
| Deep Merge | Recursa em todos os níveis aninhados | Por arrayConcat/arrayReplace selecionado | Camadas de config multi-ambiente, fusão de dicionários i18n |
| Shallow Merge | Mescla apenas o nível superior | Sobrescrita total | Substituição simples estilo Object.assign |
| Concatenar Array | Nível superior | Concatenado em novo array | Agregação de API paginadas, fusão de dados mock |
| Substituir Array | Nível superior | A última entrada vence | Override de config de Feature Flag |
Implementações Comuns de Mesclagem JSON Comparadas
| Implementação / biblioteca | Linguagem | Comportamento padrão | Notas |
|---|---|---|---|
| Object.assign | JavaScript | Fusão superficial | Lib padrão ES2015; após ES2017 pode usar `Object.assign({}, a, b)` |
| { ...a, ...b } | JavaScript | Fusão superficial | Operador spread; sintaxe mais concisa |
| lodash.merge | JavaScript | Fusão profunda | Arrays concatenados (sem sobrescrita); npm install lodash.merge |
| mergedeep | Python | Fusão profunda | strategy='override' para mudar concat de array para replace |
| deepmerge (Python) | Python | Fusão profunda | Outra implementação popular; pip install deepmerge |
| jq -s 'add' | Shell | Soma de arrays | Fusão de objetos requer `reduce .[] as $i ({}; . * $i)` |
Authoritative References
- Comprimir JSON
- CSV para JSON
- JSON para CSV
- JSON Diff
- JSON Escape / Unescape
- Achatamento de JSON
- Formatador JSON
- Gerador de JSON
- Consulta JSONPath
- Mesclar JSON
- Reparar JSON
- Validador JSON Schema
- Ordenar JSON
- JSON Stringify
- JSON para HTML
- JSON para Java
- JSON to Markdown
- JSON para SQL
- JSON para TOML
- JSON para TypeScript
- XML para JSON
- JSON para XML
- YAML para JSON
- JSON para YAML
- JSON para Python
- JSON para Go
- JSON para Rust
- JSON para Swift
- JSON para C#
- JSON para C++
- JSON para PHP