Achatamento de JSON

Separador:
Profundidade máx.:(0=unlimited)

Ferramenta online para achatar e reverter JSON: converta JSON aninhado em pares chave-valor separados por pontos com um clique. Separador personalizado, expansão de índices de array e reversão, tudo processado localmente para máxima segurança.

Sugestões Relacionadas

Casos de uso

  • Consultas e agregações no MongoDB: converta JSON aninhado em estrutura plana com pontos e use diretamente em find, update e pipelines de agregação, sem escrever caminhos manualmente
  • Exportação para CSV/Excel: depois de achatar um objeto em vários níveis, importe em um DataFrame Pandas ou no Excel usando as chaves como cabeçalhos de coluna, mantendo um registro por linha
  • Indexação no Elasticsearch: documentos planos são mais adequados para armazenamento e consulta em mecanismos de busca, expandindo todos os campos aninhados em chaves planas
  • Debug de APIs: compare a estrutura aninhada de requisição e resposta; após o achatamento, os nomes dos campos ficam mais legíveis, ajudando a localizar campos ausentes ou erros de tipo
  • Pré-processamento de configurações: achate arquivos como package.json ou settings.json em variáveis de ambiente, prontas para serem injetadas em pipelines Docker ou CI
  • Logs e monitoramento: achate eventos de log complexos e aninhados antes de gravá-los em um data warehouse, facilitando agregações e visualizações por campo

Como Usar

  1. Cole o JSON a ser processado na caixa de entrada à esquerda, ou faça upload de um arquivo .json local pelo botão de upload, ou clique em exemplo para carregar uma amostra aninhada
  2. Na barra de ferramentas, alterne entre os modos "Achatamento" e "Reversão" e, nas opções na parte inferior, defina o separador, o tratamento de arrays e a profundidade máxima de expansão
  3. A ferramenta processa em tempo real: a área de saída à direita exibe imediatamente o resultado, junto com a contagem de chaves e a profundidade máxima
  4. Clique no botão Copiar para enviar o resultado à área de transferência, ou em Baixar para salvá-lo como arquivo .json no seu computador

Recursos

  • Conversão bidirecional: suporta achatamento e desachatamento de JSON, alternando sem perdas entre estruturas aninhadas e planas
  • Separador personalizado: ponto por padrão, mas aceita underline, barra, duplo underline ou qualquer caractere, adaptando-se a diferentes sistemas downstream
  • Tratamento de array configurável: expanda em chaves indexadas (ex.: items.0.items.1) ou mantenha o array inteiro como valor único, cobrindo cenários tabulares e de configuração
  • Limite de profundidade máxima: defina um teto de expansão para evitar chaves longas demais em estruturas profundamente aninhadas
  • Estatísticas em tempo real: após o processamento, mostra imediatamente a quantidade de chaves e a profundidade máxima, facilitando a avaliação do tamanho da saída
  • Processamento local para privacidade: parsing e transformações acontecem no navegador, dados JSON nunca são enviados a servidores, ideal para APIs sensíveis e configurações de produção
  • Upload de arquivo e exemplos: aceita arquivos .json e oferece um exemplo pronto para carregar e validar a conversão rapidamente
  • Copiar e baixar: copie o resultado para a área de transferência com um clique ou baixe como arquivo .json padrão para processamentos posteriores

Exemplos de Código

Achatamento de JSON em JavaScript

javascript
function flatten(obj, prefix = '', sep = '.') {
  return Object.entries(obj).reduce((acc, [key, value]) => {
    const newKey = prefix ? `${prefix}${sep}${key}` : key;
    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
      Object.assign(acc, flatten(value, newKey, sep));
    } else {
      acc[newKey] = value;
    }
    return acc;
  }, {});
}

flatten({ user: { name: 'Alice', contact: { email: 'a@x.com' } } });
// => { 'user.name': 'Alice', 'user.contact.email': 'a@x.com' }

Achatamento de JSON em Python

python
def flatten(obj, parent_key='', sep='.'):
    items = {}
    for key, value in obj.items():
        new_key = f"{parent_key}{sep}{key}" if parent_key else key
        if isinstance(value, dict):
            items.update(flatten(value, new_key, sep))
        else:
            items[new_key] = value
    return items

import json
print(json.dumps(flatten({'user': {'name': 'Alice'}}), indent=2))
# => {"user.name": "Alice"}

Achatamento de JSON via linha de comando com jq

bash
# Converte JSON aninhado em estrutura plana com pontos
jq '[paths(scalars) as $p | {"key": $p | join("."), "value": getpath($p)}] | from_entries' data.json

# Para reverter a estrutura aninhada a partir de JSON plano
# Requer jq 1.7+ com filtros de terceiros, ou use o modo "Reversão" desta ferramenta

Perguntas frequentes

O que é o achatamento de JSON e quando ele é necessário?

O achatamento de JSON é o processo que converte objetos ou arrays aninhados em vários níveis em pares chave-valor em um único nível. Os nomes das chaves aninhadas são concatenados por um separador (o ponto por padrão). Por exemplo, {"user":{"name":"Alice"}} vira {"user.name":"Alice"}. Você precisa dele quando for exportar JSON aninhado para CSV, escrever consultas dot notation no MongoDB, indexar no Elasticsearch, configurar variáveis de ambiente ou se integrar a sistemas downstream que só aceitam chaves planas.

É possível reverter a estrutura aninhada a partir de um JSON plano?

Sim. Esta ferramenta inclui o modo de desachatamento: basta manter o mesmo separador usado no achatamento para reconstruir, sem perdas, o objeto e os arrays aninhados originais. Índices inteiros consecutivos (0, 1, 2…) são reconhecidos automaticamente e restaurados como arrays, sem configuração manual.

É possível usar um separador personalizado? Como os arrays são tratados?

Sim. O separador pode ser ponto, underline, barra, duplo underline ou qualquer caractere, com até 3 caracteres. Os arrays podem ser tratados de duas formas: por padrão, são expandidos em chaves numéricas (items.0, items.1); alternativamente, marque a opção para manter o array inteiro como valor único. Também é possível definir uma profundidade máxima de expansão (0 = sem limite): acima do nível informado, a estrutura aninhada permanece compacta, evitando chaves longas demais.

Processar JSON online compromete a privacidade?

Não. Parsing, achatamento e desachatamento acontecem inteiramente no navegador local. Os dados JSON nunca são enviados a um servidor. JSON de APIs de produção, configurações ao vivo e dados pessoais ficam no seu dispositivo durante toda a operação.

Como usar o achatamento de JSON no MongoDB?

O MongoDB usa dot notation por padrão para acessar campos aninhados. Por exemplo, para consultar documentos em que user.contact.email é alice@example.com, usa-se { "user.contact.email": "alice@example.com" }. Depois de converter um JSON aninhado em estrutura plana com esta ferramenta, as chaves obtidas podem ser coladas diretamente em consultas find, updates e pipelines de agregação, eliminando a escrita manual de caminhos.

Como exportar para CSV ou Excel um JSON achatado?

A saída do achatamento já é um mapa chave-valor em um único nível, que pode ser copiado diretamente para nossa ferramenta JSON para CSV ou importado para Excel/Pandas usando as chaves com pontos como cabeçalhos de coluna. Para arrays de objetos, recomenda-se usar o limite de profundidade ou manter o array compacto, evitando que um único registro seja quebrado em várias linhas.

Em quais cenários é melhor usar underline ou barra como separador?

O ponto (user.address.city) é o mais universal, indicado para objetos JS e consultas MongoDB. O underline (user_address_city) é ideal para nomes de coluna em SQL, variáveis Python e variáveis de ambiente. A barra (user/address/city) lembra um caminho de arquivo e é usada com frequência em parâmetros de path de APIs REST. O duplo underline (user__address__city) é adequado para frameworks como Django, em que o underline já aparece nas chaves.

Uma chave que já contém ponto ou underline pode gerar conflito?

Sim. Por exemplo, uma chave original user.name, achatada com ponto como separador, vira user.name.name; no desachatamento, seria dividida em user → name → name, adicionando um nível indesejado. Quando as chaves contêm o caractere separador, prefira um separador que não apareça nos nomes (como barra ou duplo underline) ou faça escape/renomeação das chaves antes da operação.

Como os objetos dentro de arrays são expandidos?

Por padrão, são expandidos por índices numéricos: por exemplo, um array orders com dois objetos gera orders.0.id, orders.0.total, orders.1.id, orders.1.total. Se o sistema downstream exige uma tabela plana, essa estrutura corresponde diretamente a várias linhas em CSV. No desachatamento, índices inteiros consecutivos (0, 1, 2…) são reconhecidos e restaurados como arrays automaticamente, sem opções extras.

JSONs muito grandes travam o processamento?

A ferramenta roda no navegador: respostas de API comuns (de dezenas a centenas de KB) são processadas em segundos. Para arquivos de alguns MB ou mais, recomenda-se usar ferramentas de linha de comando como jq localmente, para evitar pressão de memória no navegador. Caso precise processar online mesmo assim, comprima ou reduza os campos antes de colar, ou divida o arquivo em vários lotes.

Para que serve o limite de profundidade máxima?

O limite de profundidade máxima restringe a expansão a um certo nível: aninhamentos além do limite são mantidos compactos como valor único. Tem dois usos comuns: evitar chaves muito longas em configurações profundas e respeitar limites de tamanho de nome de coluna em alguns bancos (por exemplo, SQL Server, que tem teto de 128 caracteres). O valor padrão é 0 (sem limite); ajuste conforme sua necessidade.

É possível salvar ou reutilizar o resultado?

Sim. Após o processamento, você pode copiar o resultado para a área de transferência com um clique ou baixá-lo como arquivo .json padrão. Tudo é feito localmente: não é preciso criar conta e nenhum dado é armazenado no servidor.

Solução de Problemas

Mensagem "A entrada não é um JSON válido"

Causa: o texto JSON contém erros de sintaxe, como aspas ausentes, vírgulas extras, parênteses não fechados ou valores booleanos escritos em estilo Python (True/False). Solução: use as ferramentas de formatação/validação JSON incluídas no nosso kit para verificar a sintaxe. Lembre-se de que booleanos e null devem estar em minúsculas e sem aspas, e as chaves devem usar aspas duplas.

Conflito de chaves após o achatamento e níveis errados no desachatamento

Causa: uma chave original já contém o separador escolhido (por exemplo, user.name com ponto como separador), criando um nível extra na divisão. Solução: use um separador que não apareça nos nomes das chaves (barra, duplo underline ou um caractere personalizado), ou aplique escape/substituição nas chaves antes da operação.

Após a expansão dos arrays, o CSV exportado gera mais linhas do que o esperado

Causa: por padrão, os elementos do array são expandidos em chaves com índice numérico, gerando um conjunto de pares chave-valor para cada elemento, que multiplicado pelos demais campos produz vários registros. Solução: se quiser um objeto por linha, marque "Manter o array inteiro como valor único", ou indique na ferramenta CSV para não expandir o campo array. Se quiser um elemento do array por linha, esse é o comportamento esperado.

O desachatamento não retorna o array esperado

Causa: apenas chaves com índices inteiros consecutivos (0, 1, 2…) são restauradas como array; chaves como orders.first ou orders.second são reconhecidas como objeto. Solução: ao achatar, não renomeie os índices numéricos, ou ajuste manualmente os nomes das chaves do array para a forma orders.0, orders.1 com índices puramente numéricos antes de desachatar.

Chaves muito longas ou nomes de coluna truncados pelo banco

Causa: um JSON profundamente aninhado, depois de achatado, pode produzir chaves-caminho que excedem o limite de tamanho de nome de coluna de bancos como SQL Server ou PostgreSQL. Solução: defina nas opções da ferramenta a "Profundidade máxima de expansão": acima do nível informado, o aninhamento é mantido compacto. Alternativamente, decomponha a estrutura aninhada ou renomeie chaves profundas antes do processamento.

O navegador fica lento ou trava em arquivos grandes

Causa: JSONs muito grandes (dezenas de MB ou mais) consomem muita memória do navegador, causando travamentos ou falhas da página. Solução: divida o arquivo em partes ou recorra a ferramentas de linha de comando como jq, flatten-json ou scripts Python. Esta ferramenta é otimizada para respostas de API, configurações e entradas de log de tamanhos comuns.