Naformátujte a zkrášlete svá data JSON s řádným odsazením. Zpřehledňuje surový JSON s barevným zvýrazněním a validací.
Formátujte a zkrášlete svůj JSON pomocí tohoto jednoduchého nástroje
Naformátovaný JSON se zde zobrazí...
JSON (JavaScript Object Notation) je lehký formát pro výměnu dat, který se stal standardem pro výměnu dat v webových aplikacích. I přes svou jednoduchost může být JSON data obtížné číst, když jsou zmenšená nebo postrádají správné formátování. Tento nástroj vám pomůže transformovat surové, neformátované JSON řetězce do dobře strukturovaného, odsazeného formátu, který je mnohem snazší číst a analyzovat.
Formátování JSON (známé také jako "hezké tisknutí") přidává konzistentní odsazení, zalomení řádků a mezery, aby vizuálně reprezentovalo hierarchickou strukturu JSON dat. To je obzvlášť cenné při práci s komplexními vnořenými objekty nebo velkými datovými sadami, kde by jinak mohly být vztahy mezi prvky obtížně rozpoznatelné.
Náš nástroj pro formátování JSON poskytuje jednoduché rozhraní pro zkrášlení vašich JSON dat s řádným odsazením a strukturou, což je činí čitelnějšími pro lidi, zatímco si zachovávají svou platnost pro stroje.
JSON je postaven na dvou základních strukturách:
{}. Každé jméno je následováno dvojtečkou : a páry jsou odděleny čárkami ,.1 {"jméno": "John", "věk": 30, "město": "New York"}
2 []. Hodnoty jsou odděleny čárkami ,.1 ["jablko", "banán", "třešeň"]
2 Hodnoty JSON mohou být:
"Ahoj světe"42 nebo 3.14159true nebo falsenull{"klíč": "hodnota"}[1, 2, 3]Platný JSON musí dodržovat tyto syntaktické pravidla:
Běžné syntaktické chyby zahrnují:
Formátování JSON transformuje kompaktní, zmenšený JSON do čitelnější podoby tímto způsobem:
Analýza: JSON řetězec je nejprve analyzován, aby se zajistilo, že je platný a aby se vytvořila in-memory reprezentace datové struktury.
Odsazení: Každá úroveň vnoření objektů a polí je odsazena (typicky o 2 nebo 4 mezery), aby se vizuálně reprezentovala hierarchie.
Zalomení řádků: Nové řádky jsou přidány po každém vlastnosti nebo prvku pole pro zlepšení čitelnosti.
Mezery: Konzistentní mezery jsou přidány kolem dvojteček a čárek.
Například tento zmenšený JSON:
1{"jméno":"John Doe","věk":30,"adresa":{"ulice":"123 Hlavní St","město":"Anytown","stát":"CA"},"koníčky":["čtení","turistika","fotografie"]}
2Se stává tímto formátovaným JSON:
1{
2 "jméno": "John Doe",
3 "věk": 30,
4 "adresa": {
5 "ulice": "123 Hlavní St",
6 "město": "Anytown",
7 "stát": "CA"
8 },
9 "koníčky": [
10 "čtení",
11 "turistika",
12 "fotografie"
13 ]
14}
15Náš formátovač používá standardní odsazení 2 mezery na úroveň, což je běžná konvence v komunitě vývojářů a poskytuje dobrý kompromis mezi kompaktností a čitelností.
Kritickým aspektem formátování JSON je ověření. Než může být JSON formátován, musí být syntakticky platný podle specifikace JSON. Běžné chyby ověření zahrnují:
Syntaktické chyby:
Chyby datového typu:
undefined nebo NaNKdyž narazíte na neplatný JSON, chybová zpráva může pomoci identifikovat problém. Většina parserů JSON bude indikovat pozici, kde došlo k selhání analýzy, což může pomoci lokalizovat problém. Náš nástroj poskytuje jasné chybové zprávy, které vám pomohou identifikovat a opravit problémy ve vašich JSON datech.
Formátování JSON je cenné v mnoha scénářích:
Při práci s RESTful API formátovaný JSON usnadňuje:
Mnoho moderních aplikací používá JSON pro konfiguraci:
Formátovaný JSON pomáhá při:
Správně formátovaný JSON je nezbytný při:
Jasné formátování JSON je cenné pro:
Zatímco náš webový formátovač JSON je pohodlný pro rychlé úkoly formátování, existuje několik alternativ pro různé scénáře:
Moderní prohlížeče zahrnují schopnosti formátování JSON:
Většina vývojových prostředí nabízí formátování JSON:
Pro uživatele terminálu nebo automatizaci:
jq je mocný příkazový procesor JSONjson_pp je předinstalován na mnoha unixových systémechpython -m json.tool poskytuje rychlé formátování pomocí PythonuPři formátování JSON v aplikací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 byl vytvořen Douglasem Crockfordem na počátku 2000. let jako lehká alternativa k XML. Formát byl odvozen z syntaxe objektového literálu JavaScriptu, ale navržen tak, aby byl nezávislý na jazyce. V roce 2006 byl JSON formálně specifikován v RFC 4627 a rychle získal popularitu díky své jednoduchosti a kompatibilitě s JavaScriptem.
Před JSON byl XML dominantním formátem pro výměnu dat, ale jeho rozvláčnost a složitost jej činily nepohodlným pro mnoho aplikací. JSON nabídl stručnější syntaxi, která byla snazší na čtení a psaní, jak pro lidi, tak pro stroje. Také se dokonale shodoval s objektovým modelem JavaScriptu, což z něj činilo přirozenou volbu pro webové aplikace.
Přijetí JSON zrychlilo s nástupem AJAX a RESTful API v polovině 2000. let. Do 2010. let se stal de facto standardem pro webová API, konfigurační soubory a ukládání dat v NoSQL databázích, jako jsou MongoDB a CouchDB.
Dnes je JSON podporován prakticky každým programovacím jazykem a používá se v nesčetných aplikacích napříč webem. Jeho jednoduchost, flexibilita a univerzální podpora z něj učinily jeden z nejdůležitějších datových formátů v moderním výpočetním prostředí.
Zde jsou příklady, jak formátovat JSON v různých programovacích jazycích:
1// JavaScript JSON formátování
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// Příklad použití
12const rawJSON = '{"jméno":"John","věk":30,"město":"New York"}';
13console.log(formatJSON(rawJSON));
141# Python JSON formátování
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# Příklad použití
12raw_json = '{"jméno":"John","věk":30,"město":"New York"}'
13print(format_json(raw_json))
141// Java JSON formátování 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 = "{\"jméno\":\"John\",\"věk\":30,\"město\":\"New York\"}";
19 System.out.println(formatJSON(rawJSON));
20 }
21}
221// PHP JSON formátování
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// Příklad použití
11$rawJSON = '{"jméno":"John","věk":30,"město":"New York"}';
12echo formatJSON($rawJSON);
131# Ruby JSON formátování
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# Příklad použití
14raw_json = '{"jméno":"John","věk":30,"město":"New York"}'
15puts format_json(raw_json)
161// C# JSON formátování 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 = "{\"jméno\":\"John\",\"věk\":30,\"město\":\"New York\"}";
23 Console.WriteLine(FormatJSON(rawJSON));
24 }
25}
261// Go JSON formátování
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 := `{"jméno":"John","věk":30,"město":"New York"}`
26 fmt.Println(formatJSON(rawJSON))
27}
28Při práci s formátováním JSON buďte si vědomi těchto potenciálních výzev:
Velmi velké JSON soubory (několik megabajtů nebo více) mohou způsobit problémy s výkonem v prohlížečích založených na formátování. Pro takové případy:
jqExtrémně vnořený JSON (více než 10-20 úrovní) se může stát obtížně navigovatelným, i když je formátovaný. V těchto případech:
JSON podporuje Unicode, ale některé formátovače mohou mít problémy s určitými znaky:
JSON neuvádí přesnost pro čísla, což může vést k problémům s velmi velkými celými čísly nebo hodnotami s plovoucí desetinnou čárkou:
Platný JSON zahrnuje prázdné objekty {} a pole [], které by měly být správně formátovány:
{}[]Objevte další nástroje, které by mohly být užitečné pro vaši pracovní postup.