Formatter JSON

Ce este formatarea JSON?

Formatarea JSON este procesul de transformare a datelor JSON într-o reprezentare consistentă și ușor de citit de către om prin adăugarea de indentare, spații albe și întreruperi de linie – fără a altera structura sau conținutul. O formatare corectă face JSON-ul mai ușor de inspectat, depanat, partajat și editat, menținând în același timp compatibilitatea cu mașinile și instrumentele software.

JSON ignoră, prin definiție, spațiile albe în afara valorilor de tip șir de caractere. Totuși, JSON-ul slab formatat (sau minimizat) — lipsit de indentare sau scris pe o singură linie — poate fi aproape imposibil de citit sau modificat corect de către om.

Formatare vs. Minimizare JSON

• Formatarea adaugă spații, indentare și întreruperi de linie pentru claritate și lizibilitate.
• Minimizarea elimină tot spațiul inutil pentru maximă compactare și eficiență în stocare sau transfer.
• Un formatter JSON robust permite comutarea între aceste moduri, facilitând alternarea între versiuni prietenoase cu omul și optimizate pentru mașină, după nevoie.

Exemplu: JSON Minimizat vs. JSON Formatat

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

De ce să formatezi JSON?

• Lizibilitate: Indentarea și întreruperile corecte de linie facilitează inspectarea obiectelor imbricate, identificarea erorilor și înțelegerea structurilor complexe de date dintr-o privire.
• Depanare: Identificarea și rezolvarea problemelor cu date invalide sau neașteptate este mult mai simplă când poți scana vizual și urmări cheile, valorile și nivelurile de imbricare.
• Colaborare: JSON-ul bine formatat este mai ușor de revizuit, discutat și editat în recenzii de cod, documentație sau fișiere partajate.
• Controlul versiunilor: Git și alte unelte VCS produc diferențe mai semnificative cu JSON formatat, facilizând urmărirea modificărilor în timp.
• Conformitate: Multe ghiduri de stil și linters automate (precum Prettier, ESLint sau jq) impun o formatare consistentă pentru claritate și standardizare.
• Compatibilitate cu unelte: Unele API-uri, CLI-uri și editoare necesită input formatat pentru o interacțiune umană mai ușoară sau pentru jurnalizare.

Cum funcționează un formatter JSON?

1. Parcurgerea: Formatter-ul încearcă mai întâi să parseze textul tău de intrare folosind un parser JSON strict. Acest pas verifică sintaxa — detectând probleme precum ghilimele lipsă, virgule suplimentare sau caractere neescapeate.
2. Frumos tipărit: Odată valid, datele parse-uite sunt serializate înapoi ca șir de caractere cu o indentare definită de utilizator (de regulă 2 sau 4 spații) și întreruperi de linie, creând o versiune "frumos tipărită".

Dacă inputul nu este JSON valid, formatter-ul va afișa o eroare sau un mesaj util care indică locația și natura problemei.

Opțiuni de formatare

• Indentare: Setează numărul de spații per nivel (până la 8).
• Sortează cheile obiectelor alfabetic
• Folosește tab-uri pentru indentare în loc de spații
• Escapează caractere non-ASCII ca Unicode
• Minimizează output-ul (linie unică, fără spații)

Probleme comune rezolvate prin formatare

• JSON pe o singură linie/minimizat: Datele returnate de API-uri sau din fișiere jurnal sunt adesea minimate pentru eficiența lățimii de bandă, făcând editarea manuală dificilă. Formatarea restabilește lizibilitatea pentru revizuire și editare.
• Indentare inconsistentă: JSON-ul lipit din surse diverse poate avea tab-uri, spații mixte sau adâncimi de indentare inconsistente. Reformatarea normalizează aceste diferențe, îmbunătățind claritatea și consistența.
• Structuri mari/imbricate: Listele sau obiectele profund imbricate (de ex. fișiere de configurare sau răspunsuri API complexe) devin ușor de gestionat și navigate când sunt formatate, cu vizualizări pliabile în editoarele suportate.

Caz real: Formatarea răspunsurilor API

La integrarea cu API-uri terțe (precum AWS, Stripe sau Google Cloud), răspunsurile sunt adesea compactate pentru viteză. Formatarea JSON-ului îl face mai ușor de inspectat pentru câmpuri lipsă, depanat pentru valori neașteptate sau partajat cu echipa.

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

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

Cum să formatezi JSON cu acest instrument

1. Lipește sau încarcă JSON-ul brut, minimizat sau slab formatat în zona de input.
2. Selectează opțiunile de formatare (mărimea indentării, sortarea cheilor etc.).
3. Apasă "Formatează" pentru a procesa inputul.
4. Vizualizează sau copiază output-ul curat și lizibil. Dacă se găsesc erori, mesajele detaliate de sintaxă te vor ajuta să le repari.

Toată formatarea se realizează în mod securizat în browserul tău — datele tale nu părăsesc niciodată dispozitivul.

Exemple de Cod pentru Formatarea JSON

Vezi cum să formatezi JSON în diverse limbaje de programare. Aceste exemple demonstrează tehnici de formatare de bază.

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