Formátujte a zlepšujte svoje JSON dáta s riadnym odsadením. Robí surový JSON čitateľným so zvýraznením syntaxe a validáciou.
Naformátujte a zkrášlete svoj JSON pomocou tohto jednoduchého nástroja
Naformátovaný JSON sa tu objaví...
JSON (JavaScript Object Notation) je ľahký formát na výmenu dát, ktorý sa stal štandardom pre výmenu dát v webových aplikáciách. Napriek svojej jednoduchosti sa môžu dáta vo formáte JSON stať ťažko čitateľnými, keď sú minifikované alebo postrádajú správne formátovanie. Tento nástroj vám pomôže transformovať surové, neformátované JSON reťazce do dobre štruktúrovaného, odsadeného formátu, ktorý je oveľa ľahšie čitateľný a analyzovateľný.
Formátovanie JSON (známe aj ako "krásne tlačenie") pridáva konzistentné odsadenie, riadkové zlomy a medzery, aby vizuálne znázornilo hierarchickú štruktúru dát JSON. To je obzvlášť cenné pri práci s komplexnými vnorenými objektmi alebo veľkými súbormi dát, kde by inak mohli byť vzťahy medzi prvkami ťažko rozpoznateľné.
Náš nástroj na formátovanie JSON poskytuje jednoduché rozhranie na zlepšenie čitateľnosti vašich dát JSON s riadnym odsadením a štruktúrou, pričom zachováva svoju platnosť pre stroje.
JSON je postavený na dvoch základných štruktúrach:
{}. Každý názov je nasledovaný dvojbodkou : a páry sú oddelené čiarkami ,.1 {"name": "John", "age": 30, "city": "New York"}
2 []. Hodnoty sú oddelené čiarkami ,.1 ["apple", "banana", "cherry"]
2 Hodnoty JSON môžu byť:
"Hello World"42 alebo 3.14159true alebo falsenull{"key": "value"}[1, 2, 3]Platný JSON musí dodržiavať tieto pravidlá syntaxe:
Bežné syntaktické chyby zahŕňajú:
Formátovanie JSON transformuje kompaktný, minifikovaný JSON do čitateľnejšej formy týmto spôsobom:
Analýza: JSON reťazec je najprv analyzovaný, aby sa zabezpečilo, že je platný a aby sa vytvorila reprezentácia dátovej štruktúry v pamäti.
Odsadenie: Každá vnorená úroveň objektov a polí je odsadená (typicky o 2 alebo 4 medzery), aby sa vizuálne znázornila hierarchia.
Riadkové zlomy: Nové riadky sú pridané po každej vlastnosti alebo prvku poľa na zlepšenie čitateľnosti.
Medzery: Konzistentné medzery sú pridané okolo dvojbodiek a čiark.
Napríklad, tento minifikovaný JSON:
1{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}
2Sa stáva týmto formátovaným JSON:
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}
15Náš formátovač používa štandardné odsadenie 2 medzami na úroveň, čo je bežná konvencia v vývojárskej komunite a poskytuje dobrú rovnováhu medzi kompaktnosťou a čitateľnosťou.
Kritickým aspektom formátovania JSON je validácia. Predtým, ako môže byť JSON formátovaný, musí byť syntakticky platný podľa špecifikácie JSON. Bežné chyby validácie zahŕňajú:
Syntaktické chyby:
Chyby typu dát:
undefined alebo NaNKeď narazíte na neplatný JSON, chybové hlásenie môže pomôcť identifikovať problém. Väčšina analyzátorov JSON označí pozíciu, kde analýza zlyhala, čo môže pomôcť lokalizovať problém. Náš nástroj poskytuje jasné chybové hlásenia, aby vám pomohol identifikovať a opraviť problémy vo vašich dátach JSON.
Formátovanie JSON je cenné v mnohých scenároch:
Pri práci s RESTful API formátovaný JSON uľahčuje:
Mnohé moderné aplikácie používajú JSON na konfiguráciu:
Formátovaný JSON pomáha pri:
Správne formátovaný JSON je nevyhnutný pri:
Jasné formátovanie JSON je cenné pre:
Aj keď je náš webový formátovač JSON pohodlný pre rýchle úlohy formátovania, existuje niekoľko alternatív pre rôzne scenáre:
Moderné prehliadače obsahujú schopnosti formátovania JSON:
Väčšina vývojových prostredí ponúka formátovanie JSON:
Pre používateľov terminálu alebo automatizáciu:
jq je výkonný príkazový procesor JSONjson_pp je predinštalovaný na mnohých unixových systémochpython -m json.tool poskytuje rýchle formátovanie pomocou PythonuPri formátovaní JSON v aplikáciách:
1// JavaScript
2const formatted = JSON.stringify(jsonObject, null, 2);
31# Python
2import json
3formatted = json.dumps(json_object, indent=2)
41// Java s 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 bol vytvorený Douglasom Crockfordom na začiatku 2000-tych rokov ako ľahšia alternatíva k XML. Formát bol odvodený od syntaxe literálu objektu JavaScript, ale navrhnutý tak, aby bol nezávislý od jazyka. V roku 2006 bol JSON formálne špecifikovaný v RFC 4627 a rýchlo získal popularitu vďaka svojej jednoduchosti a kompatibilite s JavaScriptom.
Pred JSON bol XML dominantným formátom pre výmenu dát, ale jeho rozsiahlosť a zložitost robili jeho používanie nepríjemným pre mnohé aplikácie. JSON ponúkol kompaktnejšiu syntax, ktorá bola ľahšie čitateľná a zapisovateľná, ako pre ľudí, tak pre stroje. Taktiež sa dokonale zladil s modelom objektov JavaScript, čo ho urobilo prirodzenou voľbou pre webové aplikácie.
Prijatie JSON sa urýchlilo so vzostupom AJAX a RESTful API v polovici 2000-tych rokov. Do 2010-tych rokov sa stal de facto štandardom pre webové API, konfiguračné súbory a ukladanie dát v NoSQL databázach ako MongoDB a CouchDB.
Dnes JSON podporuje prakticky každý programovací jazyk a používa sa v nespočetných aplikáciách na webe. Jeho jednoduchosť, flexibilita a univerzálna podpora z neho urobili jeden z najdôležitejších formátov dát v modernej informatike.
Tu sú príklady, ako formátovať JSON v rôznych programovacích jazykoch:
1// JavaScript formátovanie JSON
2function formatJSON(jsonString) {
3 try {
4 const parsedData = JSON.parse(jsonString);
5 return JSON.stringify(parsedData, null, 2);
6 } catch (error) {
7 return `Chyba: ${error.message}`;
8 }
9}
10
11// Príklad použitia
12const rawJSON = '{"name":"John","age":30,"city":"New York"}';
13console.log(formatJSON(rawJSON));
141# Python formátovanie JSON
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"Chyba: {str(e)}"
10
11# Príklad použitia
12raw_json = '{"name":"John","age":30,"city":"New York"}'
13print(format_json(raw_json))
141// Java formátovanie JSON s 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 "Chyba: " + 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 formátovanie JSON
2function formatJSON($jsonString) {
3 $result = json_decode($jsonString);
4 if (json_last_error() !== JSON_ERROR_NONE) {
5 return "Chyba: " . json_last_error_msg();
6 }
7 return json_encode($result, JSON_PRETTY_PRINT);
8}
9
10// Príklad použitia
11$rawJSON = '{"name":"John","age":30,"city":"New York"}';
12echo formatJSON($rawJSON);
131# Ruby formátovanie JSON
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 "Chyba: #{e.message}"
10 end
11end
12
13# Príklad použitia
14raw_json = '{"name":"John","age":30,"city":"New York"}'
15puts format_json(raw_json)
161// C# formátovanie JSON s 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 $"Chyba: {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 formátovanie JSON
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("Chyba: %s", err.Error())
14 }
15
16 formattedBytes, err := json.MarshalIndent(parsedData, "", " ")
17 if err != nil {
18 return fmt.Sprintf("Chyba: %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}
28Pri práci s formátovaním JSON si dávajte pozor na tieto potenciálne výzvy:
Veľmi veľké súbory JSON (niekoľko megabajtov alebo viac) môžu spôsobiť problémy s výkonom v prehliadačoch. Pre takéto prípady:
jqExtrémne vnorené JSON (viac ako 10-20 úrovní) sa môžu stať ťažko navigovateľnými, aj keď sú formátované. V takýchto prípadoch:
JSON podporuje Unicode, ale niektoré formátovače môžu mať problémy s určitými znakmi:
JSON nešpecifikuje presnosť pre čísla, čo môže spôsobiť problémy s veľmi veľkými celými alebo desatinnými hodnotami:
Platný JSON obsahuje prázdne objekty {} a polia [], ktoré by mali byť správne formátované:
{}[]Objavte ďalšie nástroje, ktoré by mohli byť užitočné pre vašu pracovnú postupnosť