Como Fazer Pretty Print em JSON

Fazer pretty print de JSON torna os dados brutos legíveis com indentação adequada e quebras de linha. Isso é essencial para depuração, documentação, desenvolvimento de APIs e qualquer cenário onde humanos precisem inspecionar dados estruturados. Sem o pretty print, o JSON aparece como uma única linha contínua de texto que é quase impossível de analisar visualmente. Este guia cobre todos os métodos para formatar JSON em diferentes ambientes, desde ferramentas online até utilitários de linha de comando e bibliotecas de código.

O Que É Pretty Print?

Pretty printing (também chamado de embelezamento ou formatação) pega o JSON compacto e adiciona espaços em branco para torná-lo legível. Um objeto JSON compacto como {"nome":"João","idade":30,"hobbies":["ler","codar"]} se torna uma representação estruturada e indentada:

{
  "nome": "João",
  "idade": 30,
  "hobbies": [
    "ler",
    "codar"
  ]
}

O processo não altera os dados — apenas sua apresentação visual. A maioria dos pretty printers oferece indentação configurável (2 espaços, 4 espaços ou tabs) e ordenação opcional de chaves. Alguns também oferecem realce de sintaxe, visualização em árvore colapsável e destaque de erros para JSON inválido.

Método Online

A ferramenta Help2Code JSON Formatter fornece formatação instantânea com realce de sintaxe, validação e visualização em árvore. É a maneira mais rápida de formatar JSON sem instalar nenhum software. Basta colar sua string JSON na área de entrada, e a ferramenta a formata em tempo real. Principais recursos:

• Formatação em tempo real enquanto você digita ou cola
• Realce de sintaxe para chaves, strings, números, booleanos e nulos
• Validação JSON com mensagens de erro específicas por linha
• Visualização em árvore colapsável para navegar em estruturas profundamente aninhadas
• Download da saída formatada como arquivo
• Modo Minificar para comprimir JSON formatado de volta ao formato compacto
• Copiar para área de transferência com um clique

Esta ferramenta é ideal para desenvolvedores que precisam inspecionar rapidamente respostas de API, depurar arquivos de configuração ou compartilhar JSON formatado com colegas.

Comparação de Métodos

DevTools do Navegador

Todos os navegadores modernos incluem pretty print de JSON embutido em suas ferramentas de desenvolvedor. Quando você registra objetos no console usando console.log(), o navegador os exibe automaticamente em uma visualização em árvore interativa e colapsável. No entanto, para mais controle sobre a formatação, use JSON.stringify() com opções de formatação:

// No console do navegador
const data = {
  name: "John",
  age: 30,
  hobbies: ["reading", "coding"],
  address: {
    street: "123 Main St",
    city: "Boston",
    zip: "02101"
  }
};

// Pretty print com indentação de 2 espaços
console.log(JSON.stringify(data, null, 2));

// Pretty print com indentação de 4 espaços
console.log(JSON.stringify(data, null, 4));

// Pretty print com indentação por tab
console.log(JSON.stringify(data, null, '\t'));

// Usando console.table para arrays de objetos
const users = [
  { id: 1, name: "Alice", role: "Admin" },
  { id: 2, name: "Bob", role: "User" }
];
console.table(users);

A aba Network do Chrome DevTools também inclui um visualizador JSON embutido para respostas de API. Quando uma resposta tem Content-Type: application/json, a aba Preview formata e realça automaticamente a sintaxe do corpo da resposta com seções colapsáveis.

VS Code

O Visual Studio Code oferece excelente suporte para edição e formatação de JSON pronto para uso:

1. Formatar Documento: Selecione o conteúdo JSON e pressione Shift+Alt+F (Windows/Linux) ou Shift+Option+F (Mac), ou clique com o botão direito e selecione "Format Document".
2. Auto-formatar ao salvar: Adicione "editor.formatOnSave": true ao seu settings.json para formatar automaticamente arquivos JSON ao salvar.
3. JSON com Comentários (.jsonc): O VS Code suporta arquivos JSON que contêm comentários, comumente usados para arquivos de configuração como settings.json e launch.json.

Extensões adicionais do VS Code para manipulação de JSON incluem:

• Prettier - Formatador de código que suporta JSON com opções personalizáveis
• JSON Tools - Adiciona comandos de ordenação, minificação e formatação
• Bracket Pair Colorizer - Colore pares de colchetes correspondentes para JSON profundamente aninhado

Linha de Comando (jq)

jq é um poderoso processador JSON de linha de comando que lida com formatação, filtragem, transformação e consulta. Está disponível em todas as plataformas via gerenciadores de pacotes e é a ferramenta de referência para manipulação de JSON em scripts:

# Formatação básica - pipe o JSON para jq com o filtro identidade
echo '{"name":"test","value":123}' | jq .

# Saída colorida (desabilitada por padrão em pipes)
echo '{"name":"test"}' | jq -C .

# Ler de arquivo e formatar
jq . file.json

# Salvar saída formatada
jq . file.json > formatted.json

# Formatar com indentação específica (padrão é 2)
jq --indent 4 . file.json

# Minificar JSON (remover espaços em branco)
jq -c . file.json

# Ordenar chaves de objeto alfabeticamente
jq -S . file.json

# Extrair e formatar um campo específico
cat data.json | jq '.users' | jq .

# Pretty print e colorir em um comando
cat messy.json | jq -C . | less -R

jq também pode ser combinado com outras ferramentas de linha de comando para pipelines poderosos de processamento de dados:

# Buscar resposta de API e formatar
curl https://api.example.com/users | jq .

# Formatar apenas os primeiros N itens
curl https://api.example.com/users | jq '.[:5]'

# Transformar e formatar
cat data.json | jq '{name: .user.name, email: .user.email}'

Métodos Específicos por Linguagem

Toda linguagem de programação importante inclui pretty print de JSON nativo ou baseado em bibliotecas:

JavaScript:

const pretty = JSON.stringify(obj, null, 2); // indentação de 2 espaços
const compact = JSON.stringify(obj); // sem espaços em branco

// Com função replacer personalizada para filtrar/transformar valores
const filtered = JSON.stringify(obj, ['name', 'age'], 2);

// Replacer personalizado para ocultar campos sensíveis
const redacted = JSON.stringify(obj, (key, value) => {
  if (key === 'password' || key === 'ssn') return '***';
  return value;
}, 2);

// Usando util.inspect no Node.js para mais controle
const util = require('util');
console.log(util.inspect(obj, { colors: true, depth: null, sorted: true }));

Python:

import json

data = {"name": "John", "age": 30, "active": True}

# Pretty print básico com indentação de 2 espaços
pretty = json.dumps(data, indent=2)

# Ordenar chaves alfabeticamente
pretty = json.dumps(data, indent=2, sort_keys=True)

# Garantir que caracteres não-ASCII sejam preservados (não escapados)
pretty = json.dumps(data, indent=2, ensure_ascii=False)

# Separadores personalizados para saída mais compacta
compact = json.dumps(data, separators=(',', ':'))

# Pretty print diretamente no console
print(json.dumps(data, indent=2, sort_keys=True))

PHP:

$data = ["name" => "John", "age" => 30, "hobbies" => ["reading"]];

// Pretty print básico
$pretty = json_encode($data, JSON_PRETTY_PRINT);

// Preservar caracteres Unicode
$pretty = json_encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);

// Ordenar chaves
$pretty = json_encode($data, JSON_PRETTY_PRINT | JSON_SORT_KEYS);

// Formatar com escape para HTML
$pretty = json_encode($data, JSON_PRETTY_PRINT | JSON_HEX_TAG | JSON_HEX_AMP);

Ruby:

require 'json'

data = { name: "John", age: 30, active: true }

# Pretty print
puts JSON.pretty_generate(data)

# Opções personalizadas
puts JSON.pretty_generate(data, indent: "    ")

Go:

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    data := map[string]interface{}{
        "name": "John",
        "age": 30,
    }
    pretty, _ := json.MarshalIndent(data, "", "  ")
    fmt.Println(string(pretty))
}

Validação JSON Durante a Formatação

A maioria das ferramentas de pretty print também valida a sintaxe JSON. JSON inválido não pode ser formatado porque o analisador não consegue determinar a estrutura pretendida. Erros comuns de validação JSON incluem:

• Vírgulas finais ([1, 2,]) - Embora permitidas em JavaScript, vírgulas finais são inválidas em JSON
• Aspas simples ('valor') - JSON requer aspas duplas para strings
• Ausência de aspas em chaves ({nome: "João"}) - Chaves devem estar entre aspas
• Caracteres de controle não escapados - Tabulação, nova linha e retorno de carro devem ser escapados como \t, \n, \r
• Comentários - JSON não suporta comentários; use o formato JSONC se comentários forem necessários

Quando Usar Cada Método

Escolher o método certo depende do seu fluxo de trabalho:

• Formatação pontual: Ferramenta online (mais rápida, sem instalação)
• Durante o desenvolvimento: DevTools do navegador ou VS Code (integrado ao seu fluxo de trabalho)
• Em scripts e automação: jq (compatível com pipelines, scriptável)
• Formatação programática em aplicações: Métodos específicos de linguagem (JavaScript JSON.stringify, Python json.dumps, PHP json_encode)
• Arquivos grandes: jq ou ferramentas de linha de comando (eficientes em memória para streaming)

Conclusão

Fazer pretty print de JSON é uma habilidade fundamental para qualquer desenvolvedor que trabalhe com APIs, arquivos de configuração ou processamento de dados. Com métodos disponíveis para todos os ambientes — desde ferramentas online até utilitários de linha de comando e todas as principais linguagens de programação — sempre há uma maneira de tornar seu JSON legível. A chave é escolher a ferramenta certa para seu contexto: rápida e conveniente para inspeções rápidas, poderosa e scriptável para pipelines automatizados.