Formatați și înfrumusețați datele JSON cu o indentare corectă. Face JSON-ul brut lizibil cu evidențierea sintaxei și validarea.
Formatează și îmbunătățește JSON-ul tău cu acest instrument simplu
JSON-ul formatat va apărea aici...
JSON (JavaScript Object Notation) este un format de schimb de date ușor, care a devenit standardul pentru schimbul de date în aplicațiile web. În ciuda simplității sale, datele JSON pot deveni dificile de citit atunci când sunt minificate sau lipsesc formatarea corespunzătoare. Acest instrument te ajută să transformi șirurile JSON brute, neformatate, într-un format bine structurat, indentat, care este mult mai ușor de citit și analizat.
Formatarea JSON (cunoscută și sub numele de "printare frumoasă") adaugă o indentare consistentă, întreruperi de linie și spațiere pentru a face structura ierarhică a datelor JSON vizibilă. Acest lucru este deosebit de valoros atunci când lucrezi cu obiecte complexe sau seturi de date mari, unde relațiile dintre elemente ar putea fi altfel greu de discernut.
Instrumentul nostru de formatare JSON oferă o interfață simplă pentru a îmbunătăți citirea datelor tale JSON cu o indentare corespunzătoare și o structură, făcându-le mai ușor de citit pentru oameni, păstrându-le în același timp valide pentru mașini.
JSON este construit pe două structuri principale:
{}. Fiecare nume este urmat de un două puncte : iar perechile sunt separate prin virgule ,.1 {"name": "John", "age": 30, "city": "New York"}
2 []. Valorile sunt separate prin virgule ,.1 ["apple", "banana", "cherry"]
2 Valorile JSON pot fi:
"Hello World"42 sau 3.14159true sau falsenull{"key": "value"}[1, 2, 3]JSON-ul corect trebuie să respecte aceste reguli de sintaxă:
Erorile comune de sintaxă includ:
Formatarea JSON transformă JSON-ul compact, minificat, într-o formă mai ușor de citit prin:
Analiza: Șirul JSON este mai întâi analizat pentru a se asigura că este valid și pentru a crea o reprezentare în memorie a structurii de date.
Indentare: Fiecare nivel de obiecte și array-uri este indentat (de obicei cu 2 sau 4 spații) pentru a reprezenta vizual ierarhia.
Întreuperi de linie: Noi linii sunt adăugate după fiecare proprietate sau element de array pentru a îmbunătăți citirea.
Spațiere: Spațierea consistentă este adăugată în jurul două puncte și virgule.
De exemplu, acest JSON minificat:
1{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}
2Devine acest JSON formatat:
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}
15Formatterul nostru folosește o indentare standard de 2 spații pe nivel, care este o convenție comună în comunitatea de dezvoltare și oferă un bun echilibru între compactitate și citire.
Un aspect critic al formatarea JSON este validarea. Înainte ca JSON-ul să poată fi formatat, trebuie să fie sintactic valid conform specificației JSON. Erorile comune de validare includ:
Erori de sintaxă:
Erori de tip de date:
undefined sau NaNCând întâlnești JSON invalid, mesajul de eroare poate ajuta la identificarea problemei. Cele mai multe parsere JSON vor indica poziția unde analiza a eșuat, ceea ce poate ajuta la localizarea problemei. Instrumentul nostru oferă mesaje de eroare clare pentru a te ajuta să identifici și să corectezi problemele din datele tale JSON.
Formatarea JSON este valoroasă în numeroase scenarii:
Când lucrezi cu API-uri RESTful, JSON-ul formatat face mai ușor:
Multe aplicații moderne folosesc JSON pentru configurație:
Formatarea JSON ajută atunci când:
JSON-ul formatat corect este esențial atunci când:
Formatarea JSON clară este valoroasă pentru:
În timp ce formatterul nostru JSON bazat pe web este convenabil pentru sarcini rapide de formatare, mai multe alternative există pentru diferite scenarii:
Browserele moderne includ capacități de formatare JSON:
Cele mai multe medii de dezvoltare oferă formatarea JSON:
Pentru utilizatorii de terminal sau automatizare:
jq este un procesor JSON puternic în linie de comandăjson_pp vine preinstalat pe multe sisteme Unixpython -m json.tool oferă formatare rapidă folosind PythonCând formatezi JSON în cadrul aplicațiilor:
1// JavaScript
2const formatted = JSON.stringify(jsonObject, null, 2);
31# Python
2import json
3formatted = json.dumps(json_object, indent=2)
41// Java cu 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 a fost creat de Douglas Crockford la începutul anilor 2000 ca o alternativă ușoară la XML. Formatul a fost derivat din sintaxa literară a obiectelor JavaScript, dar a fost conceput pentru a fi independent de limbaj. În 2006, JSON a fost specificat formal în RFC 4627 și a câștigat rapid popularitate datorită simplității și compatibilității sale cu JavaScript.
Înainte de JSON, XML era formatul dominant pentru schimbul de date, dar verbositatea și complexitatea sa l-au făcut incomod pentru multe aplicații. JSON a oferit o sintaxă mai concisă care era mai ușor de citit și scris, atât pentru oameni, cât și pentru mașini. De asemenea, s-a aliniat perfect cu modelul de obiecte JavaScript, făcându-l alegerea naturală pentru aplicațiile web.
Adopția JSON-ului a accelerat odată cu creșterea AJAX-ului și API-urilor RESTful la mijlocul anilor 2000. Până în anii 2010, a devenit standardul de facto pentru API-urile web, fișierele de configurație și stocarea datelor în baze de date NoSQL precum MongoDB și CouchDB.
Astăzi, JSON este suportat de aproape toate limbajele de programare și este utilizat în nenumărate aplicații pe web. Simplitatea, flexibilitatea și suportul său universal au făcut din acesta unul dintre cele mai importante formate de date în informatica modernă.
Iată exemple de cum să formatezi JSON în diverse limbaje de programare:
1// Formatarea JSON în JavaScript
2function formatJSON(jsonString) {
3 try {
4 const parsedData = JSON.parse(jsonString);
5 return JSON.stringify(parsedData, null, 2);
6 } catch (error) {
7 return `Eroare: ${error.message}`;
8 }
9}
10
11// Exemplu de utilizare
12const rawJSON = '{"name":"John","age":30,"city":"New York"}';
13console.log(formatJSON(rawJSON));
141# Formatarea JSON în 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"Eroare: {str(e)}"
10
11# Exemplu de utilizare
12raw_json = '{"name":"John","age":30,"city":"New York"}'
13print(format_json(raw_json))
141// Formatarea JSON în Java cu 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 "Eroare: " + 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// Formatarea JSON în PHP
2function formatJSON($jsonString) {
3 $result = json_decode($jsonString);
4 if (json_last_error() !== JSON_ERROR_NONE) {
5 return "Eroare: " . json_last_error_msg();
6 }
7 return json_encode($result, JSON_PRETTY_PRINT);
8}
9
10// Exemplu de utilizare
11$rawJSON = '{"name":"John","age":30,"city":"New York"}';
12echo formatJSON($rawJSON);
131# Formatarea JSON în 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 "Eroare: #{e.message}"
10 end
11end
12
13# Exemplu de utilizare
14raw_json = '{"name":"John","age":30,"city":"New York"}'
15puts format_json(raw_json)
161// Formatarea JSON în C# cu 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 $"Eroare: {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// Formatarea JSON în 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("Eroare: %s", err.Error())
14 }
15
16 formattedBytes, err := json.MarshalIndent(parsedData, "", " ")
17 if err != nil {
18 return fmt.Sprintf("Eroare: %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}
28Când lucrezi cu formatarea JSON, fii conștient de aceste provocări potențiale:
Fișierele JSON foarte mari (câteva megabytes sau mai mult) pot cauza probleme de performanță în formatterele bazate pe browser. Pentru astfel de cazuri:
jqJSON-ul extrem de înnăscut (mai mult de 10-20 de niveluri) poate deveni dificil de navigat chiar și atunci când este formatat. În aceste cazuri:
JSON suportă Unicode, dar unele formattere pot avea probleme cu anumite caractere:
JSON-ul nu specifică precizia pentru numere, ceea ce poate duce la probleme cu numere foarte mari sau valori în virgulă mobilă:
JSON-ul valid include obiecte goale {} și array-uri [], care ar trebui să fie formatate corespunzător:
{}[]Descoperiți mai multe instrumente care ar putea fi utile pentru fluxul dvs. de lucru