Formátovač JSON

Naformátujte a zkrášlete svoj JSON pomocou tohto jednoduchého nástroja

Raw JSON vstup*

Naformátovaný JSON výstup

Naformátovaný JSON sa tu objaví...

Formatter JSON

Úvod

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.

Syntax a štruktúra JSON

JSON je postavený na dvoch základných štruktúrach:

Objekty: Zbierky párov názov/hodnota uzavreté v zložených zátvorkách {}. Každý názov je nasledovaný dvojbodkou : a páry sú oddelené čiarkami ,.

   {"name": "John", "age": 30, "city": "New York"}

Polia: Usporiadané zoznamy hodnôt uzavreté v hranatých zátvorkách []. Hodnoty sú oddelené čiarkami ,.

   ["apple", "banana", "cherry"]

Hodnoty JSON môžu byť:

Reťazce (v dvojitých úvodzovkách): "Hello World"
Čísla: 42 alebo 3.14159
Booleany: true alebo false
Null: null
Objekty: {"key": "value"}
Polia: [1, 2, 3]

Platný JSON musí dodržiavať tieto pravidlá syntaxe:

Názvy musia byť reťazce v dvojitých úvodzovkách
Hodnoty musia byť jedným z platných typov dát JSON
Nie sú povolené žiadne koncové čiarky
Komentáre nie sú povolené
Funkcie alebo metódy nie sú povolené

Bežné syntaktické chyby zahŕňajú:

Chýbajúce alebo nezodpovedajúce zátvorky/zložené zátvorky
Chýbajúce úvodzovky okolo názvov vlastností
Používanie jednoduchých úvodzoviek namiesto dvojitých úvodzoviek
Zahrnutie koncových čiarkov
Používanie nedefinovaných hodnôt

Ako funguje formátovanie JSON

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:

{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}

Sa stáva týmto formátovaným JSON:

{
  "name": "John Doe",
  "age": 30,
  "address": {
    "street": "123 Main St",
    "city": "Anytown",
    "state": "CA"
  },
  "hobbies": [
    "reading",
    "hiking",
    "photography"
  ]
}

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

Validácia JSON

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:
- Nepomenované vlastnosti
- Chýbajúce alebo nadbytočné čiarky
- Nesprávne vnorené štruktúry
- Neuzavreté reťazce, objekty alebo polia
Chyby typu dát:
- Používanie špecifických hodnôt JavaScriptu ako undefined alebo NaN
- Zahrnutie funkcií alebo metód
- Používanie jednoduchých úvodzoviek pre reťazce

Keď 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.

Prípadové použitia

Formátovanie JSON je cenné v mnohých scenároch:

Vývoj a testovanie API

Pri práci s RESTful API formátovaný JSON uľahčuje:

Preskúmanie odpovedí
Ladenie telies požiadaviek
Dokumentovanie príkladov API
Overovanie, či štruktúry dát zodpovedajú očakávaniam

Správa konfigurácie

Mnohé moderné aplikácie používajú JSON na konfiguráciu:

Súbory nastavení aplikácie
Konfigurácie prostredia
Špecifikácie zostavenia a nasadenia
Šablóny infraštruktúry ako kód (napr. AWS CloudFormation, Terraform)

Analýza a vizualizácia dát

Formátovaný JSON pomáha pri:

Preskúmaní súborov dát
Príprave dát na vizualizáciu
Pochopení schém dát
Identifikovaní vzorov v štruktúrovaných dátach

Ladenie a odstraňovanie problémov

Správne formátovaný JSON je nevyhnutný pri:

Ladení webových aplikácií
Preskúmaní localStorage alebo sessionStorage
Analýze sieťových odpovedí
Odstraňovaní problémov s integráciou dát

Vzdelávacie účely

Jasné formátovanie JSON je cenné pre:

Učenie dátových štruktúr
Demonštrovanie vnorených vzťahov
Vysvetľovanie konceptov API
Ilustrovanie princípov modelovania dát

Alternatívy

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:

Nástroje pre vývojárov prehliadača

Moderné prehliadače obsahujú schopnosti formátovania JSON:

Chrome a Edge DevTools automaticky formátujú odpovede JSON na karte Sieť
JSON prehliadač Firefox poskytuje interaktívny stromový pohľad
Rozšírenia prehliadača ako JSONView môžu formátovať JSON priamo v prehliadači

Kódové editory a IDE

Väčšina vývojových prostredí ponúka formátovanie JSON:

Visual Studio Code má zabudované formátovanie JSON (Alt+Shift+F)
JetBrains IDE (WebStorm, IntelliJ) obsahujú silné nástroje pre JSON
Sublime Text a Atom podporujú formátovanie JSON prostredníctvom pluginov

Nástroje príkazového riadku

Pre používateľov terminálu alebo automatizáciu:

jq je výkonný príkazový procesor JSON
json_pp je predinštalovaný na mnohých unixových systémoch
python -m json.tool poskytuje rýchle formátovanie pomocou Pythonu

Programové prístupy

Pri formátovaní JSON v aplikáciá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);

História

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

Príklady kódu

Tu sú príklady, ako formátovať JSON v rôznych programovacích jazykoch:

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

// Príklad použitia
const rawJSON = '{"name":"John","age":30,"city":"New York"}';
console.log(formatJSON(rawJSON));

# Python formátovanie JSON
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)}"

# Príklad použitia
raw_json = '{"name":"John","age":30,"city":"New York"}'
print(format_json(raw_json))

// Java formátovanie JSON 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 = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
        System.out.println(formatJSON(rawJSON));
    }
}

// PHP formátovanie JSON
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);
}

// Príklad použitia
$rawJSON = '{"name":"John","age":30,"city":"New York"}';
echo formatJSON($rawJSON);

# Ruby formátovanie JSON
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

# Príklad použitia
raw_json = '{"name":"John","age":30,"city":"New York"}'
puts format_json(raw_json)

// C# formátovanie JSON 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 = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
        Console.WriteLine(FormatJSON(rawJSON));
    }
}

// Go formátovanie JSON
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 := `{"name":"John","age":30,"city":"New York"}`
    fmt.Println(formatJSON(rawJSON))
}

Okrajové prípady a úvahy

Pri práci s formátovaním JSON si dávajte pozor na tieto potenciálne výzvy:

Veľké súbory JSON

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:

Zvážte použitie príkazových nástrojov ako jq
Rozdeľte JSON na menšie časti
Použite streamovacie analyzátory na spracovanie bez načítania celého súboru do pamäte

Hlboko vnorené štruktúry

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

Zvážte zjednodušenie štruktúry, ak je to možné
Použite zbaliteľné prehliadače JSON
Extrahujte a pracujte s konkrétnymi časťami JSON

Špeciálne znaky a Unicode

JSON podporuje Unicode, ale niektoré formátovače môžu mať problémy s určitými znakmi:

Uistite sa, že váš formátovač správne spracováva emoji a iné znaky Unicode
Buďte opatrní pri ovládacích znakoch a escape sekvenciách
Overte, že formátovaný výstup zachováva všetky pôvodné znaky

Presnosť čísel

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:

Buďte si vedomí toho, že niektoré implementácie JavaScriptu môžu stratiť presnosť pre celé čísla nad 53 bitov
Zvážte použitie reťazcových reprezentácií pre presné číselné hodnoty
Testujte s extrémnymi hodnotami, ak vaša aplikácia vyžaduje vysokú presnosť

Prázdne objekty a polia

Platný JSON obsahuje prázdne objekty {} a polia [], ktoré by mali byť správne formátované:

Prázdne objekty by sa mali objaviť ako {}
Prázdne polia by sa mali objaviť ako []
Vnorené prázdne štruktúry by mali zachovať správne odsadenie

Odkazy

JSON.org - Oficiálna webová stránka špecifikácie JSON
RFC 8259 - Formát výmeny dát JSON
MDN Web Docs: JSON - Komplexná dokumentácia o JSON v JavaScripte
JSON Lint - Populárny online validátor JSON
jq - Ľahký a flexibilný príkazový procesor JSON

Súvisiace nástroje

Prevádzkovateľ jednotiek času: roky, dni, hodiny, minúty, sekundy

Base64 kódovač a dekodér: Prevod textu na/z Base64

Nástroj na inverziu textu: Obrátenie poradia znakov v akomkoľvek reťazci

Prevádzač Unix časových pečiatok na dátum: Podpora 12/24 hodinového formátu

Riešiteľ kvadratických rovníc: Nájdite korene ax² + bx + c = 0

Generátor náhodných API kľúčov: Vytvorte zabezpečené 32-znakové reťazce