Formatador JSON

O que é Formatação JSON?

Formatação JSON é o processo de transformar dados JSON em uma representação consistente e legível para humanos, adicionando indentação, espaços e quebras de linha — sem alterar a estrutura ou conteúdo. A formatação correta facilita inspecionar, depurar, compartilhar e editar JSON, mantendo compatibilidade com máquinas e ferramentas de software.

JSON, por definição, ignora espaços em branco fora dos valores de texto. No entanto, JSON mal formatado (ou minificado) — sem indentação ou comprimido em uma única linha — pode ser quase impossível para humanos lerem ou modificarem com segurança.

Formatar vs. Minificar JSON

• Formatar adiciona espaços, indentação e quebras de linha para clareza e legibilidade.
• Minificar remove todos os espaços desnecessários para máxima compactação e eficiência no armazenamento ou transmissão.
• Um formatador JSON robusto permite alternar entre esses modos, facilitando escolher entre versões amigáveis ao humano e otimizadas para máquina conforme necessário.

Exemplo: JSON Minificado vs. Formatado

{"id":"3f4b2c","user":{"name":"Dana","is_active":true},"roles":["admin","editor"],"count":7}

{
  "id": "3f4b2c",
  "user": {
    "name": "Dana",
    "is_active": true
  },
  "roles": [
    "admin",
    "editor"
  ],
  "count": 7
}

Por que formatar JSON?

• Legibilidade: Indentação e quebras de linha adequadas facilitam inspecionar objetos aninhados, identificar erros e compreender estruturas complexas de dados rapidamente.
• Depuração: Solucionar problemas com dados inválidos ou inesperados é muito mais simples quando você pode examinar visualmente chaves, valores e níveis de aninhamento.
• Colaboração: JSON bem formatado facilita revisões, discussões e edições em revisões de código, documentação ou arquivos compartilhados.
• Controle de Versão: Git e outras ferramentas VCS geram diferenças mais significativas com JSON formatado, facilitando o acompanhamento de alterações ao longo do tempo.
• Conformidade: Muitas diretrizes de estilo e lintadores automáticos (como Prettier, ESLint ou jq) exigem formatação consistente para clareza e padronização.
• Compatibilidade de Ferramentas: Algumas APIs, CLIs e editores esperam entrada formatada para facilitar interação humana e registro de logs.

Como funciona um formatador JSON?

1. Análise: O formatador primeiro tenta analisar seu texto usando um parser JSON rigoroso. Essa etapa verifica a validade da sintaxe — detectando problemas como aspas faltando, vírgulas finais ou caracteres não escapados.
2. Pretty-Printing: Quando válido, os dados analisados são convertidos em uma string com indentação e quebras de linha definidas pelo usuário (geralmente 2 ou 4 espaços), criando uma versão "bem formatada".

Se o JSON for inválido, o formatador exibirá um erro ou mensagem útil indicando a localização e o tipo do problema.

Opções de formatação

• Indentação: Defina o número de espaços por nível (até 8).
• Ordenar as chaves dos objetos alfabeticamente
• Usar tabulações para indentação ao invés de espaços
• Escapar caracteres não ASCII como Unicode
• Minificar saída (linha única, sem espaços)

Problemas comuns resolvidos pela formatação

• JSON em uma única linha/minificado: Dados retornados de APIs ou logs são frequentemente minificados para economizar banda, dificultando a edição manual. A formatação restaura a legibilidade para análise e edição.
• Indentação inconsistente: JSON copiado de diversas fontes pode misturar tabs, espaços ou ter níveis de indentação irregulares. Reformatação normaliza essas diferenças, melhorando clareza e consistência.
• Estruturas grandes/ aninhadas: Arrays ou objetos profundamente aninhados (como arquivos de configuração ou respostas complexas de API) ficam navegáveis e fáceis de entender quando formatados, com visualizações recolhíveis em editores compatíveis.

Caso real: formatação de respostas de API

Ao integrar com APIs terceiras (como AWS, Stripe ou Google Cloud), as respostas costumam ser compactadas para rapidez. Formatar o JSON facilita verificar campos faltantes, depurar valores inesperados ou compartilhar com a equipe.

{"amount":2500,"currency":"usd","status":"succeeded","charges":[{"id":"ch_1Gq","amount":2500}]}

{
  "amount": 2500,
  "currency": "usd",
  "status": "succeeded",
  "charges": [
    {
      "id": "ch_1Gq",
      "amount": 2500
    }
  ]
}

Como formatar JSON com esta ferramenta

1. Cole ou envie seu JSON cru, minificado ou mal formatado na área de entrada.
2. Selecione as opções de formatação (tamanho da indentação, ordenar chaves, etc.).
3. Clique em "Formatar" para processar seu JSON.
4. Visualize ou copie o resultado limpo e legível. Se houver erros, mensagens detalhadas ajudarão a corrigir o JSON.

Toda a formatação é realizada com segurança no seu navegador — seus dados nunca saem do seu dispositivo.

Exemplos de Código para Formatação JSON

Veja como formatar JSON em várias linguagens de programação. Estes exemplos demonstram técnicas básicas de formatação.

const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
const pretty = JSON.stringify(JSON.parse(ugly), null, 2);
console.log(pretty);

import json
ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
pretty = json.dumps(json.loads(ugly), indent=2)
print(pretty)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  ugly := []byte(`{"name":"Alice","age":30,"roles":["admin","user"]}`)
  var obj interface{}
  json.Unmarshal(ugly, &obj)
  pretty, _ := json.MarshalIndent(obj, "", "  ")
  fmt.Println(string(pretty))
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) throws Exception {
    String ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}";
    ObjectMapper mapper = new ObjectMapper();
    Object obj = mapper.readValue(ugly, Object.class);
    String pretty = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
    System.out.println(pretty);
  }
}

using System;
using Newtonsoft.Json;
class Program {
  static void Main() {
    var ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}";
    var parsed = JsonConvert.DeserializeObject(ugly);
    var pretty = JsonConvert.SerializeObject(parsed, Formatting.Indented);
    Console.WriteLine(pretty);
  }
}

<?php
$ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
$obj = json_decode($ugly);
echo json_encode($obj, JSON_PRETTY_PRINT);

require 'json'
ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
pretty = JSON.pretty_generate(JSON.parse(ugly))
puts pretty

echo '{"name":"Alice","age":30,"roles":["admin","user"]}' | jq .

fn main() {
  let ugly = r#"{"name":"Alice","age":30,"roles":["admin","user"]}"#;
  let value: serde_json::Value = serde_json::from_str(ugly).unwrap();
  let pretty = serde_json::to_string_pretty(&value).unwrap();
  println!("{}", pretty);
}

import com.fasterxml.jackson.databind.ObjectMapper
fun main() {
  val ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}"
  val mapper = ObjectMapper()
  val obj = mapper.readValue(ugly, Any::class.java)
  val pretty = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj)
  println(pretty)
}

import Foundation
let ugly = "{\"name\":\"Alice\",\"age\":30,\"roles\":[\"admin\",\"user\"]}"
if let data = ugly.data(using: .utf8),
   let obj = try? JSONSerialization.jsonObject(with: data),
   let pretty = try? JSONSerialization.data(withJSONObject: obj, options: .prettyPrinted),
   let prettyString = String(data: pretty, encoding: .utf8) {
    print(prettyString)
}

const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
const pretty = JSON.stringify(JSON.parse(ugly), null, 2);
console.log(pretty);

SELECT jsonb_pretty('{"name":"Alice","age":30,"roles":["admin","user"]}'::jsonb);

SELECT JSON_PRETTY('{"name":"Alice","age":30,"roles":["admin","user"]}');

$ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
$obj = $ugly | ConvertFrom-Json
$pretty = $obj | ConvertTo-Json -Depth 10
Write-Output $pretty

use JSON;
my $ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
my $obj = decode_json($ugly);
print to_json($obj, { pretty => 1 });

import 'dart:convert';
void main() {
  const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
  final obj = jsonDecode(ugly);
  final pretty = JsonEncoder.withIndent('  ').convert(obj);
  print(pretty);
}

ugly = ~s({"name":"Alice","age":30,"roles":["admin","user"]})
{:ok, obj} = Jason.decode(ugly)
pretty = Jason.encode!(obj, pretty: true)
IO.puts(pretty)

import play.api.libs.json._
object Main extends App {
  val ugly = """{"name":"Alice","age":30,"roles":["admin","user"]}"""
  val jsValue = Json.parse(ugly)
  val pretty = Json.prettyPrint(jsValue)
  println(pretty)
}