JSON Formatuotojas

Kas yra JSON formatavimas?

JSON formatavimas – tai procesas, kai JSON duomenys pavirsta nuoseklia, žmogui suprantama forma, pridedant įtraukas, tarpus ir eilučių pertraukas – nekeičiant struktūros ar turinio. Tinkamai suformatuotas JSON lengviau apžiūrėti, taisyti, dalintis ir redaguoti, užtikrinant suderinamumą su mašinomis ir programiniais įrankiais.

Pagal apibrėžimą JSON ignoruoja tarpelius už tekstinių reikšmių ribų. Tačiau prastai suformatuotas arba sutrauktas JSON – be įtraukimų arba sutalpintas vienoje eilutėje – beveik neįskaitomas ir nepatikimai koreguojamas žmonių.

Formatavimo ir sutrumpinimo skirtumai JSON

• Formatavimas prideda tarpus, įtraukas ir eilučių perpuses, kad būtų aiškiau ir lengviau skaityti.
• Sutrumpinimas pašalina nereikalingus tarpus, maksimaliai sutrumpindamas ir efektyviai saugant arba perduodant duomenis.
• Galingas JSON formatuotojas leidžia lengvai perjungti tarp šių režimų, užtikrinant žmogui patogią arba mašinai optimizuotą išvestį pagal poreikį.

Pavyzdys: Sutrauktas vs. suformatuotas 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
}

Kodėl formatuoti JSON?

• Skaitomumas: Teisingos įtraukos ir eilutės pertraukos leidžia lengviau įžiūrėti įdėtus objektus, pastebėti klaidas ir suprasti sudėtingas duomenų struktūras akimirksniu.
• Derinimas: Probleminių ar netikėtų duomenų paieška daug paprastesnė, kai galite vizualiai peržiūrėti raktus, reikšmes ir įdėjimo lygius.
• Bendradarbiavimas: Gerai suformatuotas JSON lengviau peržiūrėti, aptarti ir redaguoti kodo peržiūrose, dokumentacijoje ar bendro naudojimo failuose.
• Versijų valdymas: Git ir kitos VCS sistemos rodo prasmingesnius skirtumus su suformatuotu JSON, palengvindamos pakeitimų sekimą laikui bėgant.
• Atitikimas: Daugelis stiliaus gairių ir automatizuotų tikrintuvų (pvz., Prettier, ESLint ar jq) reikalauja nuoseklaus formatavimo aiškumui ir standartizavimui.
• Įrankių suderinamumas: Kai kurios API, komandinės eilutės sąsajos ir redaktoriai reikalauja formatuotos įvesties patogesniam žmogaus naudojimui ar registravimui.

Kaip veikia JSON formatuotojas?

1. Analizė: Formatuotojas pirmiausia bando sukurti jūsų įvestį naudodamas griežtą JSON analizatorių. Šis žingsnis tikrina sintaksės teisingumą – gaudydamas tokias klaidas kaip trūkstamos kabutės, papildomi kableliai ar neaustiniai simboliai.
2. Gražus atspaudimas: Kai duomenys yra galiojantys, jie išvedami atgal į tekstą su naudojama vartotojo nustatyta įtrauka (dažniausiai 2 ar 4 tarpai) ir eilučių pertraukomis, sukuriant gražiai atspausdintą versiją.

Jeigu įvestis nėra galiojantis JSON, formatuotojas sukels klaidą arba pateiks naudingą pranešimą, nurodantį problemos vietą ir pobūdį.

Formatavimo parinktys

• Įtrauka: Nustatykite tarpų kiekį kiekvienam lygiui (iki 8).
• Rūšiuoti objektų raktus pagal abėcėlę
• Naudoti tabuliacijas vietoj tarpų
• Unicode simbolių neiš ASCII simbolių kodavimas
• Sutraukti išvestį (vienoje eilutėje, be tarpų)

Dažnos problemos, kurias išsprendžia formatavimas

• Vienoje eilutėje / sutrauktas JSON: Duomenys iš API ar žurnalų dažnai būna sutraukti siekiant efektyvumo, kas apsunkina rankinį redagavimą. Formatavimas atkuria skaitomumą peržiūrai ir redagavimui.
• Nenuosekli įtrauka: JSON iš įvairių šaltinių gali turėti mišrius tabuliacijų, tarpų derinius ar nevienodą įtraukos lygį. Pirminis formatavimas suvienodina šiuos skirtumus, pagerindamas aiškumą ir nuoseklumą.
• Didelės / įdėtos struktūros: Giliai įdėti masyvai ar objektai (pvz., konfigūracijos failai ar sudėtingų API atsakymai) tampa lengvai naršomi ir valdomi su formatavimu bei sulankstymo galimybėmis palaikančiuose redaktoriuose.

Tikrojo pasaulio atvejis: API atsakymų formatavimas

Integruojantis su trečiųjų šalių API (pvz., AWS, Stripe, Google Cloud), atsakymai dažnai sutraukiami dėl greičio. JSON formatavimas palengvina trūkstamų laukų peržiūrą, netikėtų reikšmių derinimą ir komandą dalinimąsi.

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

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

Kaip naudotis šiuo JSON formatuotoju

1. Įklijuokite arba įkelkite savo žalią, sutrumpintą ar prastai suformatuotą JSON į įvesties lauką.
2. Pasirinkite formatavimo parinktis (įtrauka, raktų rūšiavimas ir kt.).
3. Spustelėkite "Formatuoti", kad apdorotumėte įvestį.
4. Peržiūrėkite arba nukopijuokite švarią, skaitomą išvestį. Jei randamos klaidos, pateikiami išsamūs sintaksės pranešimai padės pataisyti JSON.

Visas formatavimo procesas vyksta saugiai jūsų naršyklėje – jūsų duomenys niekada neišeina iš įrenginio.

JSON formatavimo kodo pavyzdžiai

Sužinokite, kaip formatuoti JSON įvairiomis programavimo kalbomis. Šie pavyzdžiai iliustruoja pagrindinius formavimo metodus.

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