JSON Formatirač

Što je formatiranje JSON-a?

Formatiranje JSON-a je proces pretvaranja JSON podataka u dosljedan, lako čitljiv oblik dodavanjem uvlačenja, praznina i prijeloma redaka—bez mijenjanja njegove strukture ili sadržaja. Ispravno formatiranje olakšava pregled, otklanjanje pogrešaka, dijeljenje i uređivanje JSON-a, a istovremeno osigurava kompatibilnost s računalima i softverskim alatima.

JSON, po definiciji, zanemaruje praznine izvan tekstualnih vrijednosti. Međutim, loše formatirani (ili minificirani) JSON—bez uvlačenja ili skupljen u jedan redak—može biti gotovo nemoguće čovjeku pouzdano čitati ili mijenjati.

Formatiranje nasuprot Minificiranju JSON-a

• Formatiranje dodaje praznine, uvlačenja i prijelome redaka radi jasnoće i čitljivosti.
• Minificiranje uklanja sve nepotrebne praznine za maksimalnu kompaktnost i učinkovitost pri pohrani ili prijenosu.
• Robustan JSON formatirač omogućuje prebacivanje između ovih načina, čineći jednostavnim izmjenu između verzije prilagođene čovjeku i verzije optimizirane za stroj.

Primjer: Minificirani naspram formatiranog JSON-a

{"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
}

Zašto formatirati JSON?

• Čitljivost: Ispravno uvlačenje i prijelomi redaka olakšavaju pregled ugnežđenih objekata, pronalazak pogrešaka i razumijevanje složenih struktura podataka na prvi pogled.
• Otklanjanje pogrešaka: Rješavanje problema s nevažećim ili neočekivanim podacima je znatno jednostavnije kad možete vizualno pratiti ključeve, vrijednosti i razine ugnježđivanja.
• Suradnja: Dobro formatirani JSON je lakše pregledavati, raspravljati i uređivati tijekom pregleda koda, dokumentacije ili dijeljenih datoteka.
• Kontrola verzija: Git i drugi alati za upravljanje verzijama proizvode smislenije usporedbe (diff) s formatiranim JSON-om, što olakšava praćenje promjena tijekom vremena.
• Usuglašenost: Mnogi stilistički vodiči i automatski linteri (poput Prettier, ESLint ili jq) zahtijevaju dosljedno formatiranje radi jasnoće i standardizacije.
• Kompatibilnost alata: Neki API-ji, CLI-ji i uređivači očekuju formatirani unos za lakšu ljudsku interakciju ili zapisivanje (logging).

Kako radi JSON formatirač?

1. Parsiranje: Formatirač prvo pokušava parsirati vaš ulazni tekst pomoću stroge JSON parsere. Ovaj korak provjerava valjanost sintakse—hvatajući probleme poput nedostajućih navodnika, zarezâ na kraju ili neispravno eskapiranih znakova.
2. Pretty-Printing: Jednom kad je valjan, parsirani podaci se serijaliziraju natrag u niz znakova s korisnički definiranim uvlačenjem (obično 2 ili 4 razmaka) i prijelomima redaka, stvarajući "lijepo ispisanu" verziju.

Ako ulaz nije valjani JSON, formatirač će prikazati grešku ili korisnu poruku koja ukazuje na mjesto i prirodu problema.

Opcije formatiranja

• Uvlačenje: Postavite broj razmaka po razini (do 8).
• Sortiraj ključeve objekata abecedno
• Koristi tabove za uvlačenje umjesto razmaka
• Zamijeni ne-ASCII znakove Unicode kodovima
• Minificiraj izlaz (jedan redak, bez razmaka)

Česti problemi riješeni formatiranjem

• Jednoredni/minificirani JSON: Podaci iz API-ja ili dnevničkih datoteka često su minificirani radi uštede prostora, što otežava ručno uređivanje. Formatiranje vraća čitljivost za pregled i izmjene.
• Nekonzistentno uvlačenje: JSON iz različitih izvora može imati miješane tabove, razmake ili neujednačene dubine uvlačenja. Reformating normalizira ove razlike i poboljšava jasnoću i dosljednost.
• Velike/ugnežđene strukture: Duboko ugnežđeni nizovi ili objekti (poput konfiguracijskih datoteka ili složenih API odgovora) postaju pregledni i laki za navigaciju kad su formatirani, s mogućnošću skupljanja u podržanim uređivačima.

Primjer iz stvarnog svijeta: Formatiranje API odgovora

Prilikom integracije s vanjskim API-jima (poput AWS, Stripe ili Google Cloud), odgovori su često kompaktirani radi brzine. Formatiranje JSON izlaza olakšava pregled za nedostajuća polja, otklanjanje neočekivanih vrijednosti ili dijeljenje s kolegama.

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

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

Kako koristiti ovaj alat za formatiranje JSON-a

1. Zalijepite ili učitajte vaš sirovi, minificirani ili loše formatirani JSON u polje za unos.
2. Odaberite opcije formatiranja (veličina uvlačenja, sortiranje ključeva itd.).
3. Kliknite "Formatiraj" za obradu vašeg unosa.
4. Pogledajte ili kopirajte čist i čitljiv rezultat. Ako se pronađu greške, prikazat će se detaljne poruke o sintaksi koje će vam pomoći popraviti JSON.

Sve formatiranje se sigurno izvodi u vašem pregledniku—vaši podaci nikada ne napuštaju vaš uređaj.

Primjeri koda za formatiranje JSON-a

Pogledajte kako formatirati JSON u različitim programskim jezicima. Ovi primjeri prikazuju osnovne tehnike formatiranja.

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)
}