Whiz Tools

Formátovač JSON

Formátujte a zkrášlete svůj JSON pomocí tohoto jednoduchého nástroje

Naformátovaný JSON se zde zobrazí...

Formátovač JSON

Úvod

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.

Syntaxe a struktura JSON

JSON je postaven na dvou základních strukturách:

  1. Objekty: Kolekce párů jméno/hodnota uzavřená v složených závorkách {}. Každé jméno je následováno dvojtečkou : a páry jsou odděleny čárkami ,.
   {"jméno": "John", "věk": 30, "město": "New York"}
  1. Pole: Uložení hodnot v pořadí uzavřené v hranatých závorkách []. Hodnoty jsou odděleny čárkami ,.
   ["jablko", "banán", "třešeň"]

Hodnoty JSON mohou být:

  • Řetězce (v dvojitých uvozovkách): "Ahoj světe"
  • Čísla: 42 nebo 3.14159
  • Booleany: true nebo false
  • Null: null
  • Objekty: {"klíč": "hodnota"}
  • Pole: [1, 2, 3]

Platný JSON musí dodržovat tyto syntaktické pravidla:

  • Jména musí být řetězce v dvojitých uvozovkách
  • Hodnoty musí být jedním z platných datových typů JSON
  • Není povoleno mít závěrečné čárky
  • Komentáře nejsou povoleny
  • Funkce nebo metody nejsou povoleny

Běžné syntaktické chyby zahrnují:

  • Chybějící nebo nesprávně spárované závorky/složené závorky
  • Chybějící uvozovky kolem názvů vlastností
  • Použití jednoduchých uvozovek místo dvojitých uvozovek
  • Zahrnutí závěrečných čárek
  • Použití nedefinovaných jako hodnoty

Jak funguje formátování JSON

Formátování JSON transformuje kompaktní, zmenšený JSON do čitelnější podoby tímto způsobem:

  1. 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.

  2. Odsazení: Každá úroveň vnoření objektů a polí je odsazena (typicky o 2 nebo 4 mezery), aby se vizuálně reprezentovala hierarchie.

  3. Zalomení řádků: Nové řádky jsou přidány po každém vlastnosti nebo prvku pole pro zlepšení čitelnosti.

  4. Mezery: Konzistentní mezery jsou přidány kolem dvojteček a čárek.

Například tento zmenšený JSON:

{"jméno":"John Doe","věk":30,"adresa":{"ulice":"123 Hlavní St","město":"Anytown","stát":"CA"},"koníčky":["čtení","turistika","fotografie"]}

Se stává tímto formátovaným JSON:

{
  "jméno": "John Doe",
  "věk": 30,
  "adresa": {
    "ulice": "123 Hlavní St",
    "město": "Anytown",
    "stát": "CA"
  },
  "koníčky": [
    "čtení",
    "turistika",
    "fotografie"
  ]
}

Náš 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í.

Ověření JSON

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í:

  1. Syntaktické chyby:

    • Neuzavřené názvy vlastností
    • Chybějící nebo nadbytečné čárky
    • Nesprávně vnořené struktury
    • Neuzavřené řetězce, objekty nebo pole

  2. Chyby datového typu:

    • Použití hodnot specifických pro JavaScript, jako je undefined nebo NaN
    • Zahrnutí funkcí nebo metod
    • Použití jednoduchých uvozovek pro řetězce

Když 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.

Případy použití

Formátování JSON je cenné v mnoha scénářích:

Vývoj a testování API

Při práci s RESTful API formátovaný JSON usnadňuje:

  • Prozkoumání odpovědí
  • Ladění těla požadavků
  • Dokumentaci příkladů API
  • Ověření, že struktury dat odpovídají očekáváním

Správa konfigurace

Mnoho moderních aplikací používá JSON pro konfiguraci:

  • Soubory nastavení aplikací
  • Konfigurace prostředí
  • Specifikace sestavení a nasazení
  • Šablony infrastruktury jako kód (např. AWS CloudFormation, Terraform)

Analýza dat a vizualizace

Formátovaný JSON pomáhá při:

  • Prozkoumávání datových sad
  • Přípravě dat pro vizualizaci
  • Porozumění datovým schématům
  • Identifikaci vzorů ve strukturovaných datech

Ladění a řešení problémů

Správně formátovaný JSON je nezbytný při:

  • Ladění webových aplikací
  • Prozkoumávání localStorage nebo sessionStorage
  • Analyzování síťových odpovědí
  • Řešení problémů s integrací dat

Vzdělávací účely

Jasné formátování JSON je cenné pro:

  • Výuku datových struktur
  • Demonstrování vnořených vztahů
  • Vysvětlování konceptů API
  • Ilustraci principů modelování dat

Alternativy

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:

Nástroje pro vývojáře prohlížeče

Moderní prohlížeče zahrnují schopnosti formátování JSON:

  • Chrome a Edge DevTools automaticky formátují JSON odpovědi na kartě Síť
  • JSON prohlížeč Firefoxu poskytuje interaktivní stromový pohled
  • Rozšíření prohlížeče jako JSONView mohou formátovat JSON přímo v prohlížeči

Kódové editory a IDE

Většina vývojových prostředí nabízí formátování JSON:

  • Visual Studio Code má vestavěné formátování JSON (Alt+Shift+F)
  • JetBrains IDE (WebStorm, IntelliJ) zahrnují silné nástroje pro JSON
  • Sublime Text a Atom podporují formátování JSON prostřednictvím pluginů

Nástroje příkazového řádku

Pro uživatele terminálu nebo automatizaci:

  • jq je mocný příkazový procesor JSON
  • json_pp je předinstalován na mnoha unixových systémech
  • python -m json.tool poskytuje rychlé formátování pomocí Pythonu

Programové přístupy

Při formátování JSON v aplikacích:

// JavaScript
const formatted = JSON.stringify(jsonObject, null, 2);

# Python
import json
formatted = json.dumps(json_object, indent=2)

// Java s Gson
Gson gson = new GsonBuilder().setPrettyPrinting().create();
String formatted = gson.toJson(jsonObject);

# Ruby
require 'json'
formatted = JSON.pretty_generate(json_object)

// PHP
$formatted = json_encode($jsonObject, JSON_PRETTY_PRINT);

Historie

JSON 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í.

Příklady kódu

Zde jsou příklady, jak formátovat JSON v různých programovacích jazycích:

// JavaScript JSON formátování
function formatJSON(jsonString) {
  try {
    const parsedData = JSON.parse(jsonString);
    return JSON.stringify(parsedData, null, 2);
  } catch (error) {
    return `Chyba: ${error.message}`;
  }
}

// Příklad použití
const rawJSON = '{"jméno":"John","věk":30,"město":"New York"}';
console.log(formatJSON(rawJSON));

# Python JSON formátování
import json

def format_json(json_string):
    try:
        parsed_data = json.loads(json_string)
        return json.dumps(parsed_data, indent=2)
    except json.JSONDecodeError as e:
        return f"Chyba: {str(e)}"

# Příklad použití
raw_json = '{"jméno":"John","věk":30,"město":"New York"}'
print(format_json(raw_json))

// Java JSON formátování s Gson
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonSyntaxException;

public class JSONFormatter {
    public static String formatJSON(String jsonString) {
        try {
            Gson gson = new GsonBuilder().setPrettyPrinting().create();
            Object parsedJson = gson.fromJson(jsonString, Object.class);
            return gson.toJson(parsedJson);
        } catch (JsonSyntaxException e) {
            return "Chyba: " + e.getMessage();
        }
    }
    
    public static void main(String[] args) {
        String rawJSON = "{\"jméno\":\"John\",\"věk\":30,\"město\":\"New York\"}";
        System.out.println(formatJSON(rawJSON));
    }
}

// PHP JSON formátování
function formatJSON($jsonString) {
    $result = json_decode($jsonString);
    if (json_last_error() !== JSON_ERROR_NONE) {
        return "Chyba: " . json_last_error_msg();
    }
    return json_encode($result, JSON_PRETTY_PRINT);
}

// Příklad použití
$rawJSON = '{"jméno":"John","věk":30,"město":"New York"}';
echo formatJSON($rawJSON);

# Ruby JSON formátování
require 'json'

def format_json(json_string)
  begin
    parsed_data = JSON.parse(json_string)
    return JSON.pretty_generate(parsed_data)
  rescue JSON::ParserError => e
    return "Chyba: #{e.message}"
  end
end

# Příklad použití
raw_json = '{"jméno":"John","věk":30,"město":"New York"}'
puts format_json(raw_json)

// C# JSON formátování s Newtonsoft.Json
using Newtonsoft.Json;
using System;

class JSONFormatter
{
    public static string FormatJSON(string jsonString)
    {
        try
        {
            object parsedJson = JsonConvert.DeserializeObject(jsonString);
            return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
        }
        catch (JsonException e)
        {
            return $"Chyba: {e.Message}";
        }
    }
    
    static void Main()
    {
        string rawJSON = "{\"jméno\":\"John\",\"věk\":30,\"město\":\"New York\"}";
        Console.WriteLine(FormatJSON(rawJSON));
    }
}

// Go JSON formátování
package main

import (
    "encoding/json"
    "fmt"
)

func formatJSON(jsonString string) string {
    var parsedData interface{}
    err := json.Unmarshal([]byte(jsonString), &parsedData)
    if err != nil {
        return fmt.Sprintf("Chyba: %s", err.Error())
    }
    
    formattedBytes, err := json.MarshalIndent(parsedData, "", "  ")
    if err != nil {
        return fmt.Sprintf("Chyba: %s", err.Error())
    }
    
    return string(formattedBytes)
}

func main() {
    rawJSON := `{"jméno":"John","věk":30,"město":"New York"}`
    fmt.Println(formatJSON(rawJSON))
}

Okrajové případy a úvahy

Při práci s formátováním JSON buďte si vědomi těchto potenciálních výzev:

Velké JSON soubory

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:

  • Zvažte použití nástrojů příkazového řádku jako jq
  • Rozdělte JSON na menší části
  • Použijte streamovací analyzátory pro zpracování bez načítání celého souboru do paměti

Hluboce vnořené struktury

Extré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:

  • Zvažte zploštění struktury, pokud je to možné
  • Použijte rozbalitelné prohlížeče JSON
  • Extrahujte a pracujte s konkrétními částmi JSON

Speciální znaky a Unicode

JSON podporuje Unicode, ale některé formátovače mohou mít problémy s určitými znaky:

  • Zajistěte, aby váš formátovač správně zpracovával emoji a další Unicode znaky
  • Buďte opatrní s ovládacími znaky a escape sekvencemi
  • Ověřte, že formátovaný výstup zachovává všechny původní znaky

Číselná přesnost

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:

  • Buďte si vědomi, že některé implementace JavaScriptu mohou ztratit přesnost pro celá čísla nad 53 bity
  • Zvažte použití řetězcových reprezentací pro přesné číselné hodnoty
  • Testujte s extrémními hodnotami, pokud vaše aplikace vyžaduje vysokou přesnost

Prázdné objekty a pole

Platný JSON zahrnuje prázdné objekty {} a pole [], které by měly být správně formátovány:

  • Prázdné objekty by měly být zobrazeny jako {}
  • Prázdná pole by měla být zobrazena jako []
  • Vnořené prázdné struktury by měly zachovat správné odsazení

Odkazy

  1. JSON.org - Oficiální webová stránka specifikace JSON
  2. RFC 8259 - Formát pro výměnu dat JSON
  3. MDN Web Docs: JSON - Komplexní dokumentace o JSON v JavaScriptu
  4. JSON Lint - Oblíbený online validátor JSON
  5. jq - Lehký a flexibilní příkazový procesor JSON

Související nástroje

Převodník časových jednotek: roky, dny, hodiny, minuty, sekundy
Base64 kódovač a dekodér: Převod textu na/nebo Base64
Nástroj pro inverzi textu: Obrátit pořadí znaků v jakémkoli řetězci
Převod Unixového časového razítka na datum: Podpora 12/24 hodinového formátu
Řešitel kvadratických rovnic: Najděte kořeny ax² + bx + c = 0
Generátor náhodných API klíčů: Vytvořte bezpečné 32-znakové řetězce
Feedback