Format i embelleix les teves dades JSON amb la indentació adequada. Fa que el JSON brut sigui llegible amb ressaltat de sintaxi i validació.
Format i embelleix el teu JSON amb aquesta eina senzilla
El JSON formatat apareixerà aquí...
JSON (JavaScript Object Notation) és un format d'intercanvi de dades lleuger que s'ha convertit en l'estàndard per a l'intercanvi de dades en aplicacions web. Malgrat la seva simplicitat, les dades JSON poden esdevenir difícils de llegir quan estan minificades o manquen de format adequat. Aquesta eina t'ajuda a transformar cadenes JSON en brut i sense format en un format ben estructurat i amb indentació que és molt més fàcil de llegir i analitzar.
El formatatge JSON (també conegut com a "impressió bonica") afegeix una indentació consistent, salts de línia i espai per fer que l'estructura jeràrquica de les dades JSON sigui visualment apparent. Això és particularment valuós quan es treballa amb objectes o conjunts de dades complexos on les relacions entre els elements podrien ser difícils de discernir.
La nostra eina formatadora JSON proporciona una interfície senzilla per embelleixer les teves dades JSON amb la indentació i estructura adequades, fent-les més llegibles per als humans mentre manté la seva validesa per a les màquines.
JSON es basa en dues estructures principals:
{}. Cada nom és seguit d'un dos punts : i els parells estan separats per comes ,.1 {"nom": "John", "edat": 30, "ciutat": "Nova York"}
2 []. Els valors estan separats per comes ,.1 ["poma", "plàtan", "cirera"]
2 Els valors JSON poden ser:
"Hola món"42 o 3.14159true o falsenull{"clau": "valor"}[1, 2, 3]El JSON correcte ha de seguir aquestes regles de sintaxi:
Els errors de sintaxi comuns inclouen:
El formatatge JSON transforma JSON compacte i minificat en una forma més llegible mitjançant:
Anàlisi: La cadena JSON es processa primer per assegurar-se que és vàlida i per crear una representació en memòria de l'estructura de dades.
Indentació: Cada nivell de profunditat d'objectes i arrays s'indenta (normalment amb 2 o 4 espais) per representar visualment la jerarquia.
Sauts de línia: S'afegeixen noves línies després de cada propietat o element d'array per millorar la llegibilitat.
Espai: S'afegeix espai consistent al voltant dels dos punts i les comes.
Per exemple, aquest JSON minificat:
1{"nom":"John Doe","edat":30,"adreça":{"carrer":"123 Main St","ciutat":"Anytown","estat":"CA"},"aficions":["lectura","senderisme","fotografia"]}
2Es converteix en aquest JSON formatat:
1{
2 "nom": "John Doe",
3 "edat": 30,
4 "adreça": {
5 "carrer": "123 Main St",
6 "ciutat": "Anytown",
7 "estat": "CA"
8 },
9 "aficions": [
10 "lectura",
11 "senderisme",
12 "fotografia"
13 ]
14}
15El nostre formatador utilitza una indentació estàndard de 2 espais per nivell, que és una convenció comuna en la comunitat de desenvolupament i proporciona un bon equilibri entre la compactació i la llegibilitat.
Un aspecte crític del formatatge JSON és la validació. Abans que JSON pugui ser formatat, ha de ser sintàcticament vàlid segons l'especificació JSON. Els errors de validació comuns inclouen:
Errors de Sintaxi:
Errors de Tipus de Dades:
undefined o NaNQuan et trobes amb JSON no vàlid, el missatge d'error pot ajudar a identificar el problema. La majoria dels analitzadors JSON indicaran la posició on la anàlisi ha fallat, cosa que pot ajudar a localitzar el problema. La nostra eina proporciona missatges d'error clars per ajudar-te a identificar i solucionar problemes en les teves dades JSON.
El formatatge JSON és valuós en nombrosos escenaris:
Quan treballes amb APIs RESTful, el JSON formatat facilita:
Moltes aplicacions modernes utilitzen JSON per a la configuració:
El JSON formatat ajuda quan:
La formatació JSON adequada és essencial quan:
Una formatació JSON clara és valuosa per a:
Tot i que el nostre formatador JSON basat en web és convenient per a tasques ràpides de formatatge, existeixen diverses alternatives per a diferents escenaris:
Els navegadors moderns inclouen capacitats de formatatge JSON:
La majoria dels entorns de desenvolupament ofereixen formatatge JSON:
Per a usuaris de terminal o automatització:
jq és un potent processador de JSON de línia de comandamentjson_pp ve preinstal·lat en molts sistemes Unixpython -m json.tool proporciona un formatatge ràpid mitjançant PythonQuan formateges JSON dins d'aplicacions:
1// JavaScript
2const formatted = JSON.stringify(jsonObject, null, 2);
31# Python
2import json
3formatted = json.dumps(json_object, indent=2)
41// Java amb Gson
2Gson gson = new GsonBuilder().setPrettyPrinting().create();
3String formatted = gson.toJson(jsonObject);
41# Ruby
2require 'json'
3formatted = JSON.pretty_generate(json_object)
41// PHP
2$formatted = json_encode($jsonObject, JSON_PRETTY_PRINT);
3JSON va ser creat per Douglas Crockford a principis dels anys 2000 com una alternativa lleugera a XML. El format es va derivar de la sintaxi de literals d'objectes de JavaScript, però dissenyat per ser independent del llenguatge. El 2006, JSON es va especificar formalment a l'RFC 4627, i ràpidament va guanyar popularitat gràcies a la seva simplicitat i compatibilitat amb JavaScript.
Abans de JSON, XML era el format dominant per a l'intercanvi de dades, però la seva verbositat i complexitat el feien pesat per a moltes aplicacions. JSON va oferir una sintaxi més concisa que era més fàcil de llegir i escriure, tant per als humans com per a les màquines. També s'ajustava perfectament al model d'objectes de JavaScript, convertint-se en l'elecció natural per a les aplicacions web.
L'adopció de JSON es va accelerar amb l'augment d'AJAX i les APIs RESTful a mitjans dels anys 2000. A principis dels anys 2010, s'havia convertit en l'estàndard de facto per a APIs web, fitxers de configuració i emmagatzematge de dades en bases de dades NoSQL com MongoDB i CouchDB.
Avui, JSON és compatible amb pràcticament tots els llenguatges de programació i s'utilitza en infinitat d'aplicacions a la web. La seva simplicitat, flexibilitat i suport universal l'han convertit en un dels formats de dades més importants en la computació moderna.
Aquí hi ha exemples de com formatar JSON en diversos llenguatges de programació:
1// Formatatge JSON en JavaScript
2function formatJSON(jsonString) {
3 try {
4 const parsedData = JSON.parse(jsonString);
5 return JSON.stringify(parsedData, null, 2);
6 } catch (error) {
7 return `Error: ${error.message}`;
8 }
9}
10
11// Exemple d'ús
12const rawJSON = '{"nom":"John","edat":30,"ciutat":"Nova York"}';
13console.log(formatJSON(rawJSON));
141# Formatatge JSON en 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"Error: {str(e)}"
10
11# Exemple d'ús
12raw_json = '{"nom":"John","edat":30,"ciutat":"Nova York"}'
13print(format_json(raw_json))
141// Formatatge JSON en Java amb 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 "Error: " + e.getMessage();
14 }
15 }
16
17 public static void main(String[] args) {
18 String rawJSON = "{\"nom\":\"John\",\"edat\":30,\"ciutat\":\"Nova York\"}";
19 System.out.println(formatJSON(rawJSON));
20 }
21}
221// Formatatge JSON en PHP
2function formatJSON($jsonString) {
3 $result = json_decode($jsonString);
4 if (json_last_error() !== JSON_ERROR_NONE) {
5 return "Error: " . json_last_error_msg();
6 }
7 return json_encode($result, JSON_PRETTY_PRINT);
8}
9
10// Exemple d'ús
11$rawJSON = '{"nom":"John","edat":30,"ciutat":"Nova York"}';
12echo formatJSON($rawJSON);
131# Formatatge JSON en 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 "Error: #{e.message}"
10 end
11end
12
13# Exemple d'ús
14raw_json = '{"nom":"John","edat":30,"ciutat":"Nova York"}'
15puts format_json(raw_json)
161// Formatatge JSON en C# amb 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 $"Error: {e.Message}";
17 }
18 }
19
20 static void Main()
21 {
22 string rawJSON = "{\"nom\":\"John\",\"edat\":30,\"ciutat\":\"Nova York\"}";
23 Console.WriteLine(FormatJSON(rawJSON));
24 }
25}
261// Formatatge JSON en 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("Error: %s", err.Error())
14 }
15
16 formattedBytes, err := json.MarshalIndent(parsedData, "", " ")
17 if err != nil {
18 return fmt.Sprintf("Error: %s", err.Error())
19 }
20
21 return string(formattedBytes)
22}
23
24func main() {
25 rawJSON := `{"nom":"John","edat":30,"ciutat":"Nova York"}`
26 fmt.Println(formatJSON(rawJSON))
27}
28Quan treballes amb el formatatge JSON, tingues en compte aquests possibles reptes:
Fitxers JSON molt grans (varis megabytes o més) poden causar problemes de rendiment en formatadors basats en navegadors. Per a aquests casos:
jqJSON extremadament anidat (més de 10-20 nivells de profunditat) pot esdevenir difícil de navegar fins i tot quan està formatat. En aquests casos:
JSON admet Unicode, però alguns formatadors poden tenir problemes amb certs caràcters:
JSON no especifica precisió per als nombres, cosa que pot provocar problemes amb enters molt grans o valors de punt flotant:
El JSON vàlid inclou objectes buits {} i arrays [], que s'han de formatar correctament:
{}[]Descobreix més eines que podrien ser útils per al teu flux de treball