Formattatore JSON

Cos’è la Formattazione JSON?

La formattazione JSON è il processo di trasformare i dati JSON in una rappresentazione coerente e leggibile dall’uomo, aggiungendo indentazioni, spazi e interruzioni di riga—senza modificare struttura o contenuto. Una corretta formattazione rende il JSON più facile da ispezionare, correggere, condividere e modificare, mantenendo la compatibilità con macchine e strumenti software.

JSON, per definizione, ignora gli spazi bianchi fuori dai valori stringa. Tuttavia, un JSON mal formattato (o minimizzato)—privo di indentazioni o su una sola linea—può essere quasi impossibile da leggere o modificare correttamente per gli umani.

Formattare vs Minimizzare JSON

• La formattazione aggiunge spazi, indentazioni e interruzioni di riga per chiarezza e leggibilità.
• La minimizzazione rimuove tutti gli spazi superflui per massimizzare compattezza ed efficienza nello storage o trasferimento.
• Un formattatore JSON avanzato consente di passare facilmente tra queste modalità, agevolando la gestione di versioni user-friendly o ottimizzate per macchina secondo necessità.

Esempio: JSON Minimizzato vs Formattato

{"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
}

Perché Formattare il JSON?

• Leggibilità: la giusta indentazione e le interruzioni di riga facilitano l’ispezione di oggetti nidificati, l’individuazione di errori e la comprensione immediata di strutture dati complesse.
• Debugging: risolvere problemi con dati non validi o inattesi è molto più semplice quando puoi scorrere visivamente chiavi, valori e livelli di nidificazione.
• Collaborazione: JSON ben formattato è più facile da rivedere, discutere e modificare durante revisioni di codice, documentazioni o file condivisi.
• Controllo di versione: Git e altri sistemi di controllo producono differenze più significative con JSON formattato, facilitando il tracciamento delle modifiche nel tempo.
• Conformità: molte guide di stile e linter automatici (come Prettier, ESLint o jq) impongono formattazioni coerenti per chiarezza e standardizzazione.
• Compatibilità con strumenti: alcune API, CLI ed editor richiedono input formattati per una più facile interazione umana o logging.

Come Funziona un Formattatore JSON?

1. Parsing: il formattatore tenta innanzitutto di analizzare il testo di input con un parser JSON rigoroso. Questo passaggio verifica la validità sintattica—catturando errori come virgolette mancanti, virgole finali o caratteri non scappati.
2. Pretty-Printing: una volta valido, i dati analizzati vengono riserializzati in stringa con indentazione definita dall’utente (di solito 2 o 4 spazi) e interruzioni di riga, generando una versione "bella da leggere".

Se l’input non è un JSON valido, il formattatore segnala un errore o fornisce un messaggio utile indicando posizione e natura del problema.

Opzioni di Formattazione

• Indentazione: imposta il numero di spazi per livello (fino a 8).
• Ordina le chiavi degli oggetti in ordine alfabetico
• Usa tabulazioni invece degli spazi per l’indentazione
• Rappresenta i caratteri non ASCII come Unicode
• Minimizza l’output (riga singola, nessuno spazio)

Problemi Comuni Risolti dalla Formattazione

• JSON su singola riga/minimizzato: dati di API o file di log sono spesso minimizzati per efficienza di banda, rendendo difficile la modifica manuale. La formattazione ripristina la leggibilità per revisione e modifica.
• Indentazione incoerente: JSON incollato da varie fonti può avere tab, spazi o profondità di indentazione miste. La riformattazione normalizza queste differenze, migliorando chiarezza e coerenza.
• Strutture grandi/nidificate: array o oggetti profondamente annidati (come file di configurazione o risposte API complesse) diventano gestibili e navigabili grazie alla formattazione, con visualizzazioni collassabili negli editor che lo supportano.

Caso pratico: formattare risposte API

Quando si integra con API di terze parti (come AWS, Stripe o Google Cloud), le risposte sono spesso compattate per velocità. Formattare l’output JSON facilita l’ispezione di campi mancanti, il debug di valori inattesi o la condivisione con colleghi.

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

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

Come Usare Questo Strumento per Formattare JSON

1. Incolla o carica il tuo JSON grezzo, minimizzato o mal formato nell’area di input.
2. Seleziona le opzioni di formattazione (dimensione indentazione, ordinamento chiavi, ecc.).
3. Clicca su "Formatta" per elaborare il tuo input.
4. Visualizza o copia l’output pulito e leggibile. Se sono presenti errori, compariranno messaggi dettagliati per aiutarti a correggere il JSON.

Tutta la formattazione avviene in sicurezza nel tuo browser—i tuoi dati non lasciano mai il dispositivo.

Esempi di Codice per la Formattazione JSON

Scopri come formattare JSON in diversi linguaggi di programmazione. Questi esempi mostrano tecniche di formattazione di base ottimizzate per sviluppatori.

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)
}