Formatta e abbellisci i tuoi dati JSON con la giusta indentazione. Rende il JSON grezzo leggibile con evidenziazione della sintassi e validazione.
Formatta e abbellisci il tuo JSON con questo semplice strumento
Il JSON formattato apparirà qui...
JSON (JavaScript Object Notation) è un formato di interscambio dati leggero che è diventato lo standard per lo scambio di dati nelle applicazioni web. Nonostante la sua semplicità, i dati JSON possono diventare difficili da leggere quando sono minificati o privi di un formato adeguato. Questo strumento ti aiuta a trasformare stringhe JSON grezze e non formattate in un formato ben strutturato e indentato che è molto più facile da leggere e analizzare.
La formattazione JSON (nota anche come "stampa bella") aggiunge un'indentazione coerente, interruzioni di riga e spaziatura per rendere visibile la struttura gerarchica dei dati JSON. Questo è particolarmente prezioso quando si lavora con oggetti complessi annidati o grandi set di dati in cui le relazioni tra gli elementi potrebbero altrimenti essere difficili da discernere.
Il nostro strumento di formattazione JSON fornisce un'interfaccia semplice per abbellire i tuoi dati JSON con una corretta indentazione e struttura, rendendoli più leggibili per gli esseri umani mantenendo la loro validità per le macchine.
JSON è costruito su due strutture principali:
{}. Ogni nome è seguito da un due punti : e le coppie sono separate da virgole ,.1 {"name": "John", "age": 30, "city": "New York"}
2 []. I valori sono separati da virgole ,.1 ["apple", "banana", "cherry"]
2 I valori JSON possono essere:
"Hello World"42 o 3.14159true o falsenull{"key": "value"}[1, 2, 3]Il JSON corretto deve seguire queste regole di sintassi:
Gli errori di sintassi comuni includono:
La formattazione JSON trasforma JSON compatto e minificato in una forma più leggibile attraverso:
Parsing: La stringa JSON viene prima analizzata per garantire che sia valida e per creare una rappresentazione in memoria della struttura dei dati.
Indentazione: Ogni livello annidato di oggetti e array è indentato (tipicamente di 2 o 4 spazi) per rappresentare visivamente la gerarchia.
Interruzioni di Riga: Vengono aggiunte nuove righe dopo ogni proprietà o elemento dell'array per migliorare la leggibilità.
Spaziatura: Viene aggiunta una spaziatura coerente attorno ai due punti e alle virgole.
Ad esempio, questo JSON minificato:
1{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}
2Diventa questo JSON formattato:
1{
2 "name": "John Doe",
3 "age": 30,
4 "address": {
5 "street": "123 Main St",
6 "city": "Anytown",
7 "state": "CA"
8 },
9 "hobbies": [
10 "reading",
11 "hiking",
12 "photography"
13 ]
14}
15Il nostro formatter utilizza un'indentazione standard di 2 spazi per livello, che è una convenzione comune nella comunità di sviluppo e fornisce un buon equilibrio tra compattezza e leggibilità.
Un aspetto critico della formattazione JSON è la validazione. Prima che JSON possa essere formattato, deve essere sintatticamente valido secondo la specifica JSON. Gli errori di validazione comuni includono:
Errori di Sintassi:
Errori di Tipo di Dato:
undefined o NaNQuando incontri JSON non valido, il messaggio di errore può aiutare a identificare il problema. La maggior parte dei parser JSON indicherà la posizione in cui il parsing è fallito, il che può aiutare a localizzare il problema. Il nostro strumento fornisce messaggi di errore chiari per aiutarti a identificare e risolvere i problemi nei tuoi dati JSON.
La formattazione JSON è preziosa in numerosi scenari:
Quando si lavora con API RESTful, JSON formattato rende più facile:
Molte applicazioni moderne utilizzano JSON per la configurazione:
La formattazione JSON aiuta quando:
JSON formattato correttamente è essenziale quando:
Una chiara formattazione JSON è preziosa per:
Sebbene il nostro formatter JSON basato sul web sia comodo per compiti di formattazione rapidi, esistono diverse alternative per scenari diversi:
I browser moderni includono capacità di formattazione JSON:
La maggior parte degli ambienti di sviluppo offre formattazione JSON:
Per gli utenti del terminale o l'automazione:
jq è un potente processore JSON da riga di comandojson_pp è preinstallato su molti sistemi Unixpython -m json.tool fornisce una formattazione rapida utilizzando PythonQuando si formatta JSON all'interno delle applicazioni:
1// Formattazione JSON in JavaScript
2const formatted = JSON.stringify(jsonObject, null, 2);
31# Formattazione JSON in Python
2import json
3formatted = json.dumps(json_object, indent=2)
41// Formattazione JSON in Java con Gson
2Gson gson = new GsonBuilder().setPrettyPrinting().create();
3String formatted = gson.toJson(jsonObject);
41# Formattazione JSON in Ruby
2require 'json'
3formatted = JSON.pretty_generate(json_object)
41// Formattazione JSON in PHP
2$formatted = json_encode($jsonObject, JSON_PRETTY_PRINT);
3JSON è stato creato da Douglas Crockford all'inizio degli anni 2000 come un'alternativa leggera a XML. Il formato è stato derivato dalla sintassi degli oggetti letterali di JavaScript, ma progettato per essere indipendente dal linguaggio. Nel 2006, JSON è stato formalmente specificato nell'RFC 4627 e ha rapidamente guadagnato popolarità grazie alla sua semplicità e compatibilità con JavaScript.
Prima di JSON, XML era il formato dominante per l'intercambio di dati, ma la sua verbosità e complessità lo rendevano ingombrante per molte applicazioni. JSON ha offerto una sintassi più concisa che era più facile da leggere e scrivere, sia per gli esseri umani che per le macchine. Si allineava anche perfettamente con il modello degli oggetti di JavaScript, rendendolo la scelta naturale per le applicazioni web.
L'adozione di JSON è aumentata con l'ascesa di AJAX e delle API RESTful a metà degli anni 2000. Negli anni 2010, era diventato lo standard de facto per le API web, i file di configurazione e l'archiviazione dei dati in database NoSQL come MongoDB e CouchDB.
Oggi, JSON è supportato praticamente da ogni linguaggio di programmazione ed è utilizzato in innumerevoli applicazioni su web. La sua semplicità, flessibilità e supporto universale lo hanno reso uno dei formati di dati più importanti nell'informatica moderna.
Ecco esempi di come formattare JSON in vari linguaggi di programmazione:
1// Formattazione JSON in JavaScript
2function formatJSON(jsonString) {
3 try {
4 const parsedData = JSON.parse(jsonString);
5 return JSON.stringify(parsedData, null, 2);
6 } catch (error) {
7 return `Errore: ${error.message}`;
8 }
9}
10
11// Esempio di utilizzo
12const rawJSON = '{"name":"John","age":30,"city":"New York"}';
13console.log(formatJSON(rawJSON));
141# Formattazione JSON in Python
2import json
3
4def format_json(json_string):
5 try:
6 parsed_data = json.loads(json_string)
7 return json.dumps(parsed_data, indent=2)
8 except json.JSONDecodeError as e:
9 return f"Errore: {str(e)}"
10
11# Esempio di utilizzo
12raw_json = '{"name":"John","age":30,"city":"New York"}'
13print(format_json(raw_json))
141// Formattazione JSON in Java con Gson
2import com.google.gson.Gson;
3import com.google.gson.GsonBuilder;
4import com.google.gson.JsonSyntaxException;
5
6public class JSONFormatter {
7 public static String formatJSON(String jsonString) {
8 try {
9 Gson gson = new GsonBuilder().setPrettyPrinting().create();
10 Object parsedJson = gson.fromJson(jsonString, Object.class);
11 return gson.toJson(parsedJson);
12 } catch (JsonSyntaxException e) {
13 return "Errore: " + e.getMessage();
14 }
15 }
16
17 public static void main(String[] args) {
18 String rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
19 System.out.println(formatJSON(rawJSON));
20 }
21}
221// Formattazione JSON in PHP
2function formatJSON($jsonString) {
3 $result = json_decode($jsonString);
4 if (json_last_error() !== JSON_ERROR_NONE) {
5 return "Errore: " . json_last_error_msg();
6 }
7 return json_encode($result, JSON_PRETTY_PRINT);
8}
9
10// Esempio di utilizzo
11$rawJSON = '{"name":"John","age":30,"city":"New York"}';
12echo formatJSON($rawJSON);
131# Formattazione JSON in Ruby
2require 'json'
3
4def format_json(json_string)
5 begin
6 parsed_data = JSON.parse(json_string)
7 return JSON.pretty_generate(parsed_data)
8 rescue JSON::ParserError => e
9 return "Errore: #{e.message}"
10 end
11end
12
13# Esempio di utilizzo
14raw_json = '{"name":"John","age":30,"city":"New York"}'
15puts format_json(raw_json)
161// Formattazione JSON in C# con Newtonsoft.Json
2using Newtonsoft.Json;
3using System;
4
5class JSONFormatter
6{
7 public static string FormatJSON(string jsonString)
8 {
9 try
10 {
11 object parsedJson = JsonConvert.DeserializeObject(jsonString);
12 return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
13 }
14 catch (JsonException e)
15 {
16 return $"Errore: {e.Message}";
17 }
18 }
19
20 static void Main()
21 {
22 string rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
23 Console.WriteLine(FormatJSON(rawJSON));
24 }
25}
261// Formattazione JSON in Go
2package main
3
4import (
5 "encoding/json"
6 "fmt"
7)
8
9func formatJSON(jsonString string) string {
10 var parsedData interface{}
11 err := json.Unmarshal([]byte(jsonString), &parsedData)
12 if err != nil {
13 return fmt.Sprintf("Errore: %s", err.Error())
14 }
15
16 formattedBytes, err := json.MarshalIndent(parsedData, "", " ")
17 if err != nil {
18 return fmt.Sprintf("Errore: %s", err.Error())
19 }
20
21 return string(formattedBytes)
22}
23
24func main() {
25 rawJSON := `{"name":"John","age":30,"city":"New York"}`
26 fmt.Println(formatJSON(rawJSON))
27}
28Quando si lavora con la formattazione JSON, fai attenzione a queste potenziali sfide:
File JSON molto grandi (diversi megabyte o più) possono causare problemi di prestazioni nei formatter basati su browser. Per tali casi:
jqJSON estremamente annidato (più di 10-20 livelli di profondità) può diventare difficile da navigare anche quando formattato. In questi casi:
JSON supporta Unicode, ma alcuni formatter possono avere problemi con determinati caratteri:
JSON non specifica la precisione per i numeri, il che può portare a problemi con interi molto grandi o valori a virgola mobile:
JSON valido include oggetti vuoti {} e array [], che dovrebbero essere formattati correttamente:
{}[]Scopri più strumenti che potrebbero essere utili per il tuo flusso di lavoro