Formátovač JSON

Čo je formátovanie JSON?

Formátovanie JSON znamená transformáciu JSON dát do konzistentnej, ľahko čitateľnej podoby pridaním odsadenia, medzier a zalomov riadkov – bez zmeny jeho štruktúry či obsahu. Správne formátovanie uľahčuje prehliadanie, ladenie, zdieľanie a úpravu JSON, pričom zabezpečuje kompatibilitu so softvérom a strojmi.

JSON podľa definície ignoruje medzery mimo reťazcových hodnôt. Avšak zle formátovaný (alebo minifikovaný) JSON – bez odsadenia alebo zložený do jedného riadku – môže byť pre človeka takmer nečitateľný a ťažko upravovateľný.

Formátovanie vs. minifikácia JSON

• Formátovanie pridáva medzery, odsadenia a zalomenia pre prehľadnosť a čitateľnosť.
• Minifikácia odstraňuje všetky zbytočné medzery pre maximálnu kompaktnosť a efektívnosť ukladania či prenosu.
• Spoľahlivý formátovač JSON vám umožní prepínať medzi týmito režimami, takže ľahko prepnete medzi prívetivou verziou pre človeka a optimalizovanou verziou pre stroj.

Príklad: Minifikovaný verzus naformátovaný JSON

{"id":"3f4b2c","user":{"name":"Dana","is_active":true},"roles":["admin","editor"],"count":7}

{
  "id": "3f4b2c",
  "user": {
    "name": "Dana",
    "is_active": true
  },
  "roles": [
    "admin",
    "editor"
  ],
  "count": 7
}

Prečo formátovať JSON?

• Čitateľnosť: Správne odsadenie a zalomenie riadkov uľahčuje prehliadanie vnorených objektov, odhaľovanie chýb a chápanie zložitých dátových štruktúr na prvý pohľad.
• Ladenie: Odhalovanie neplatných alebo neočakávaných údajov je jednoduchšie, keď môžete vizuálne prehľadávať a sledovať kľúče, hodnoty a úrovne vnorenia.
• Spolupráca: Dobře naformátovaný JSON sa ľahšie kontroluje, diskutuje a upravuje pri prehliadkach kódu, dokumentácii alebo zdieľaných súboroch.
• Verziovanie: Nástroje ako Git vytvárajú zmysluplnejšie rozdiely (dify) pri formátovanom JSON, čo uľahčuje sledovanie zmien v čase.
• Súlad: Mnohé štýlové príručky a automatické lintery (ako Prettier, ESLint alebo jq) vyžadujú jednotné formátovanie pre jasnosť a štandardizáciu.
• Kompatibilita nástrojov: Niektoré API, CLI a editory očakávajú formátovaný vstup pre jednoduchšiu interakciu človeka alebo logovanie.

Ako funguje formátovač JSON?

1. Parsovanie: Formátovač najskôr pokúsi analyzovať váš vstupný text prísnym JSON parserom. Tento krok kontroluje syntaktickú správnosť – zachytáva chýbajúce úvodzovky, nadbytočné čiarky alebo neescapované znaky.
2. Pekné formátovanie: Po overení správnosti sa analyzované dáta prevedú späť na reťazec s používateľsky definovaným odsadením (obvykle 2 alebo 4 medzery) a zalomeniami riadkov, čím vzniká „pekná“ verzia.

Ak vstup nie je platný JSON, formátovač zobrazí chybu alebo užitočnú správu s informáciou o mieste a povahy problému.

Možnosti formátovania

• Odsadenie: Nastavte počet medzier na úroveň (max. 8).
• Zoradiť kľúče objektu podľa abecedy
• Použiť tabulátory na odsadenie namiesto medzier
• Escapovať ne-ASCII znaky ako Unicode
• Minifikovať výstup (jednoriadkový, bez medzier)

Bežné problémy riešené formátovaním

• Jednoriadkový/minifikovaný JSON: Dáta z API alebo logov bývajú často minifikované kvôli úspore prenosovej kapacity, čo sťažuje manuálnu úpravu. Formátovanie obnovuje čitateľnosť pre kontrolu a editáciu.
• Nekonzistentné odsadenie: JSON z rôznych zdrojov môže obsahovať zmiešané tabulátory, medzery alebo nevyrovnané úrovne odsadenia. Reformatovanie tieto rozdiely normalizuje a zvýrazňuje prehľadnosť.
• Veľké/vnorené štruktúry: Hlboko vnorené polia alebo objekty (napríklad konfiguračné súbory alebo komplexné odpovede API) sú po naformátovaní ľahko spracovateľné s možnosťou zbalenia vo vhodných editoroch.

Praktické použitie: Formátovanie odpovedí API

Pri integrácii s tretími stranami (ako AWS, Stripe či Google Cloud) sú odpovede často kompaktné pre rýchlosť. Formátovanie JSON výstupu uľahčuje kontrolu chýbajúcich polí, ladenie neočakávaných hodnôt a zdieľanie s kolegami.

{"amount":2500,"currency":"usd","status":"succeeded","charges":[{"id":"ch_1Gq","amount":2500}]}

{
  "amount": 2500,
  "currency": "usd",
  "status": "succeeded",
  "charges": [
    {
      "id": "ch_1Gq",
      "amount": 2500
    }
  ]
}

Ako formátovať JSON s týmto nástrojom

1. Prilepte alebo nahrajte svoj surový, minifikovaný alebo zle formátovaný JSON do vstupného poľa.
2. Vyberte možnosti formátovania (veľkosť odsadenia, zoradenie kľúčov a pod.).
3. Kliknite na „Formátovať“ pre spracovanie vstupu.
4. Prezrite si alebo skopírujte čistý, čitateľný výstup. Ak sa nájdu chyby, zobrazia sa podrobné správy na pomoc s opravou JSON.

Všetko formátovanie sa vykonáva bezpečne vo vašom prehliadači – vaše údaje nikdy neopustia zariadenie.

Ukážky kódu pre formátovanie JSON

Pozrite sa, ako formátovať JSON v rôznych programovacích jazykoch. Tieto príklady ukazujú základné techniky formátovania.

const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
const pretty = JSON.stringify(JSON.parse(ugly), null, 2);
console.log(pretty);

import json
ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
pretty = json.dumps(json.loads(ugly), indent=2)
print(pretty)

package main
import (
  "encoding/json"
  "fmt"
)
func main() {
  ugly := []byte(`{"name":"Alice","age":30,"roles":["admin","user"]}`)
  var obj interface{}
  json.Unmarshal(ugly, &obj)
  pretty, _ := json.MarshalIndent(obj, "", "  ")
  fmt.Println(string(pretty))
}

import com.fasterxml.jackson.databind.ObjectMapper;
public class Main {
  public static void main(String[] args) throws Exception {
    String ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}";
    ObjectMapper mapper = new ObjectMapper();
    Object obj = mapper.readValue(ugly, Object.class);
    String pretty = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj);
    System.out.println(pretty);
  }
}

using System;
using Newtonsoft.Json;
class Program {
  static void Main() {
    var ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}";
    var parsed = JsonConvert.DeserializeObject(ugly);
    var pretty = JsonConvert.SerializeObject(parsed, Formatting.Indented);
    Console.WriteLine(pretty);
  }
}

<?php
$ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
$obj = json_decode($ugly);
echo json_encode($obj, JSON_PRETTY_PRINT);

require 'json'
ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
pretty = JSON.pretty_generate(JSON.parse(ugly))
puts pretty

echo '{"name":"Alice","age":30,"roles":["admin","user"]}' | jq .

fn main() {
  let ugly = r#"{"name":"Alice","age":30,"roles":["admin","user"]}"#;
  let value: serde_json::Value = serde_json::from_str(ugly).unwrap();
  let pretty = serde_json::to_string_pretty(&value).unwrap();
  println!("{}", pretty);
}

import com.fasterxml.jackson.databind.ObjectMapper
fun main() {
  val ugly = "{"name":"Alice","age":30,"roles":["admin","user"]}"
  val mapper = ObjectMapper()
  val obj = mapper.readValue(ugly, Any::class.java)
  val pretty = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(obj)
  println(pretty)
}

import Foundation
let ugly = "{\"name\":\"Alice\",\"age\":30,\"roles\":[\"admin\",\"user\"]}"
if let data = ugly.data(using: .utf8),
   let obj = try? JSONSerialization.jsonObject(with: data),
   let pretty = try? JSONSerialization.data(withJSONObject: obj, options: .prettyPrinted),
   let prettyString = String(data: pretty, encoding: .utf8) {
    print(prettyString)
}

const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
const pretty = JSON.stringify(JSON.parse(ugly), null, 2);
console.log(pretty);

SELECT jsonb_pretty('{"name":"Alice","age":30,"roles":["admin","user"]}'::jsonb);

SELECT JSON_PRETTY('{"name":"Alice","age":30,"roles":["admin","user"]}');

$ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}'
$obj = $ugly | ConvertFrom-Json
$pretty = $obj | ConvertTo-Json -Depth 10
Write-Output $pretty

use JSON;
my $ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
my $obj = decode_json($ugly);
print to_json($obj, { pretty => 1 });

import 'dart:convert';
void main() {
  const ugly = '{"name":"Alice","age":30,"roles":["admin","user"]}';
  final obj = jsonDecode(ugly);
  final pretty = JsonEncoder.withIndent('  ').convert(obj);
  print(pretty);
}

ugly = ~s({"name":"Alice","age":30,"roles":["admin","user"]})
{:ok, obj} = Jason.decode(ugly)
pretty = Jason.encode!(obj, pretty: true)
IO.puts(pretty)

import play.api.libs.json._
object Main extends App {
  val ugly = """{"name":"Alice","age":30,"roles":["admin","user"]}"""
  val jsValue = Json.parse(ugly)
  val pretty = Json.prettyPrint(jsValue)
  println(pretty)
}