Formatuokite ir gražinkite savo JSON duomenis su tinkamu įtraukimu. Padaro neapdorotą JSON skaitomą su sintaksės paryškinimu ir validacija.
Su šiuo paprastu įrankiu suformatuokite ir gražiai atvaizduokite savo JSON
Suformatuotas JSON pasirodys čia...
JSON (JavaScript objektų notacija) yra lengvas duomenų mainų formatas, kuris tapo standartu duomenų mainams internetinėse programose. Nepaisant savo paprastumo, JSON duomenys gali tapti sunkiai skaitomi, kai jie yra minimizuoti arba neturi tinkamo formatavimo. Šis įrankis padeda jums paversti neformatuotus, neapdorotus JSON simbolius į gerai struktūrizuotą, įrengtą formatą, kuris yra daug lengviau skaitomas ir analizuojamas.
JSON formatavimas (dar vadinamas „gražiuoju spausdinimu“) prideda nuoseklų įtrauką, eilučių pertraukas ir tarpus, kad vizualiai parodytų JSON duomenų hierarchinę struktūrą. Tai ypač vertinga dirbant su sudėtingais įdėtais objektais ar dideliais duomenų rinkiniais, kur elementų ryšiai kitaip gali būti sunkiai atpažįstami.
Mūsų JSON formatavimo įrankis suteikia paprastą sąsają, kad pagražintumėte savo JSON duomenis su tinkamu įtraukimu ir struktūra, padarydami juos labiau skaitomus žmonėms, tuo pačiu išlaikydami jų galiojimą mašinoms.
JSON yra sukurtas iš dviejų pagrindinių struktūrų:
{}. Kiekvienas pavadinimas yra sekamas dvitaškiu : ir poros yra atskiriamos kableliais ,.1 {"name": "John", "age": 30, "city": "New York"}
2 []. Vertės yra atskiriamos kableliais ,.1 ["apple", "banana", "cherry"]
2 JSON vertės gali būti:
"Hello World"42 arba 3.14159true arba falsenull{"key": "value"}[1, 2, 3]Tinkamas JSON turi laikytis šių sintaksės taisyklių:
Dažnos sintaksės klaidos apima:
JSON formatavimas paverčia kompaktišką, minimizuotą JSON į labiau skaitomą formą:
Analizė: JSON simbolis pirmiausia analizuojamas, kad būtų užtikrinta, jog jis yra galiojantis ir kad būtų sukurtas atmintyje esantis duomenų struktūros atvaizdas.
Įtraukimas: Kiekvienas įdėtas objektų ir masyvų lygis yra įtraukiamas (paprastai 2 arba 4 tarpus) vizualiai parodyti hierarchiją.
Eilučių pertraukos: Naujų eilučių pridedama po kiekvienos savybės arba masyvo elemento, kad būtų pagerintas skaitomumas.
Tarpai: Nuoseklūs tarpai pridedami aplink dvitaškius ir kablelius.
Pavyzdžiui, šis minimizuotas JSON:
1{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}
2Tampa šiuo formatavimu:
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}
15Mūsų formatavimo įrankis naudoja standartinį 2 tarpus už lygį, kuris yra dažna konvencija kūrėjų bendruomenėje ir suteikia gerą pusiausvyrą tarp kompaktiškumo ir skaitomumo.
Kritinė JSON formatavimo dalis yra validacija. Prieš JSON galint būti formatuojamas, jis turi būti sintaktiškai galiojantis pagal JSON specifikaciją. Dažnos validacijos klaidos apima:
Sintaksės klaidos:
Duomenų tipo klaidos:
undefined arba NaNKai susiduriate su negaliojančiu JSON, klaidos pranešimas gali padėti nustatyti problemą. Dauguma JSON analizatorių nurodys vietą, kur analizavimas nepavyko, kas gali padėti rasti problemą. Mūsų įrankis pateikia aiškius klaidų pranešimus, kad padėtų jums nustatyti ir ištaisyti problemas jūsų JSON duomenyse.
JSON formatavimas yra vertingas daugybėje scenarijų:
Dirbant su RESTful API, formatintas JSON palengvina:
Daugelis šiuolaikinių programų naudoja JSON konfigūracijai:
Formatintas JSON padeda, kai:
Tinkamai formatintas JSON yra būtinas, kai:
Aiškus JSON formatavimas yra vertingas:
Nors mūsų internetinis JSON formatavimo įrankis yra patogus greitiems formatavimo užduotims, egzistuoja kelios alternatyvos skirtingoms situacijoms:
Šiuolaikinės naršyklės apima JSON formatavimo galimybes:
Dauguma plėtros aplinkų siūlo JSON formatavimą:
Terminalo vartotojams arba automatizavimui:
jq yra galingas komandų eilučių JSON apdorojimo įrankisjson_pp yra iš anksto įdiegtas daugelyje Unix sistemųpython -m json.tool suteikia greitą formatavimą naudojant PythonKai formatavote JSON programose:
1// JavaScript
2const formatted = JSON.stringify(jsonObject, null, 2);
31# Python
2import json
3formatted = json.dumps(json_object, indent=2)
41// Java su 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 buvo sukurtas Douglas Crockford 2000-ųjų pradžioje kaip lengvas alternatyvus formatas XML. Formatą sudaro JavaScript objekto literatūros sintaksė, tačiau jis buvo sukurtas kaip nepriklausomas nuo kalbos. 2006 m. JSON buvo oficialiai apibrėžtas RFC 4627, ir jis greitai įgavo populiarumą dėl savo paprastumo ir suderinamumo su JavaScript.
Prieš JSON, XML buvo dominuojantis formatas duomenų mainams, tačiau jo išsiplėtimas ir sudėtingumas padarė jį nepatogų daugeliui programų. JSON pasiūlė glaustesnę sintaksę, kuri buvo lengviau skaitoma ir rašoma tiek žmonėms, tiek mašinoms. Taip pat jis puikiai atitiko JavaScript objekto modelį, todėl tapo natūraliu pasirinkimu internetinėms programoms.
JSON priėmimas pagreitėjo su AJAX ir RESTful API atsiradimu 2000-ųjų viduryje. 2010-aisiais jis tapo de facto standartu interneto API, konfigūracijos failams ir duomenų saugojimui NoSQL duomenų bazėse, tokiose kaip MongoDB ir CouchDB.
Šiandien JSON palaiko praktiškai kiekviena programavimo kalba ir jis naudojamas nesuskaičiuojamose programose visame internete. Jo paprastumas, lankstumas ir universali parama padarė jį vienu svarbiausių duomenų formatų šiuolaikinėje kompiuterijoje.
Štai pavyzdžiai, kaip formatuoti JSON įvairiose programavimo kalbose:
1// JavaScript JSON formatavimas
2function formatJSON(jsonString) {
3 try {
4 const parsedData = JSON.parse(jsonString);
5 return JSON.stringify(parsedData, null, 2);
6 } catch (error) {
7 return `Klaida: ${error.message}`;
8 }
9}
10
11// Pavyzdžio naudojimas
12const rawJSON = '{"name":"John","age":30,"city":"New York"}';
13console.log(formatJSON(rawJSON));
141# Python JSON formatavimas
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"Klaida: {str(e)}"
10
11# Pavyzdžio naudojimas
12raw_json = '{"name":"John","age":30,"city":"New York"}'
13print(format_json(raw_json))
141// Java JSON formatavimas su 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 "Klaida: " + 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// PHP JSON formatavimas
2function formatJSON($jsonString) {
3 $result = json_decode($jsonString);
4 if (json_last_error() !== JSON_ERROR_NONE) {
5 return "Klaida: " . json_last_error_msg();
6 }
7 return json_encode($result, JSON_PRETTY_PRINT);
8}
9
10// Pavyzdžio naudojimas
11$rawJSON = '{"name":"John","age":30,"city":"New York"}';
12echo formatJSON($rawJSON);
131# Ruby JSON formatavimas
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 "Klaida: #{e.message}"
10 end
11end
12
13# Pavyzdžio naudojimas
14raw_json = '{"name":"John","age":30,"city":"New York"}'
15puts format_json(raw_json)
161// C# JSON formatavimas su 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 $"Klaida: {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// Go JSON formatavimas
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("Klaida: %s", err.Error())
14 }
15
16 formattedBytes, err := json.MarshalIndent(parsedData, "", " ")
17 if err != nil {
18 return fmt.Sprintf("Klaida: %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}
28Dirbant su JSON formatavimu, atkreipkite dėmesį į šias galimas problemas:
Labai dideli JSON failai (kelis megabaitus ar daugiau) gali sukelti našumo problemų naršyklės pagrindu veikiančiuose formatavimo įrankiuose. Tokiais atvejais:
jqEkstremaliai įdėti JSON (daugiau nei 10-20 lygių) gali tapti sunkiai naršomais net ir formatavus. Tokiais atvejais:
JSON palaiko Unicode, tačiau kai kurie formatavimo įrankiai gali turėti problemų su tam tikrais simboliais:
JSON nenurodo skaitmenų tikslumo, o tai gali sukelti problemų su labai dideliais sveikaisiais skaičiais arba plaukiojančiais taškais:
Galiojantis JSON apima tuščius objektus {} ir masyvus [], kurie turėtų būti tinkamai formatuoti:
{}[]Raskite daugiau įrankių, kurie gali būti naudingi jūsų darbo eiga.