JSON formatētājs

Kas ir JSON formatēšana?

JSON formatēšana ir process, kurā JSON dati tiek pārveidoti par vienmērīgu, cilvēkiem saprotamu formu, pievienojot atkāpes, tukšumus un rindu pārtraukumus, nemainot struktūru vai saturu. Pareiza formatēšana atvieglo JSON pārbaudi, atkļūdošanu, koplietošanu un rediģēšanu, vienlaikus saglabājot saderību ar mašīnām un programmatūras rīkiem.

JSON pēc definīcijas ignorē atstarpes ārpus virkņu vērtībām. Tomēr slikti formatēts (vai minimizēts) JSON – bez atkāpēm vai salikts vienā rindā – cilvēkiem var būt gandrīz neiespējams lasīt vai uzticami labot.

JSON formatēšana pret minimizēšanu

• Formatēšana pievieno atstarpes, atkāpes un rindu pārtraukumus skaidrībai un labākai uztveramībai.
• Minimizēšana noņem visu lieko atstarpi, lai nodrošinātu maksimālu kompaktumu un efektivitāti glabāšanā vai pārsūtīšanā.
• Spēcīgs JSON formatētājs ļauj pārslēgties starp šiem režīmiem, viegli izvēloties starp lietotājam draudzīgu vai mašīnām optimizētu formātu pēc vajadzības.

Piemērs: minimizēts pret formatētu 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
}

Kāpēc formatēt JSON?

• Lasāmība: Pareiza atkāpe un rindu pārtraukumi padara vieglāku ielūkoties iegult objektiem, pamanīt kļūdas un saprast sarežģītas datu struktūras uzreiz.
• Atkļūdošana: Problēmu risināšana ar nederīgiem vai negaidītiem datiem ir daudz vienkāršāka, ja var vizuāli pārskatīt un izsekot atslēgas, vērtības un līmeņus.
• Sadarbība: Labi formatēts JSON ir vieglāk pārskatīt, apspriest un rediģēt koda apskatēs, dokumentācijā vai koplietotos failos.
• Versiju kontrole: Git un citi VCS rīki nodrošina saprotamākas atšķirības ar formatētu JSON, atvieglojot izmaiņu izsekošanu.
• Atbilstība: Daudzi stila vadlīnijas un automatizēti linteri (piemēram, Prettier, ESLint vai jq) nodrošina konsekventu formatējumu skaidrībai un standartizācijai.
• Rīku saderība: Dažas API, CLI un redaktori sagaida formatētu ievadi ērtākai cilvēka mijiedarbībai vai žurnālfailiem.

Kā darbojas JSON formatētājs?

1. Parsēšana: Formatētājs vispirms mēģina parsēt jūsu ievadu ar stingru JSON parseri. Šis solis pārbauda sintakses pareizību – atklājot problēmas kā trūkstošas pēdiņas, liekas komatas vai neaizsargātas rakstzīmes.
2. Skaista drukāšana: Ja dati ir derīgi, tie tiek pārrakstīti atpakaļ tekstā ar lietotāja norādītajām atkāpēm (parasti 2 vai 4 atstarpes) un rindu pārtraukumiem, veidojot "skaisti drukātu" versiju.

Ja ievads nav derīgs JSON, formatētājs ziņos par kļūdu vai sniegs noderīgu paziņojumu ar problēmas atrašanās vietu un raksturu.

Formatēšanas iespējas

• Atkāpe: Iestatiet atstarpju skaitu vienā līmenī (līdz 8).
• Kārtot objekta atslēgas alfabētiski
• Lietot tabulācijas atkāpei nevis atstarpes
• Izlaist ne-ASCII rakstzīmes kā Unicode
• Minimizēt izvadi (vienā rindā, bez atstarpēm)

Biežas problēmas, ko risina formatēšana

• Vienas līnijas/minimizēts JSON: Dati no API vai žurnālfailiem bieži tiek minimizēti, lai ietaupītu joslas platumu, padarot manuālu rediģēšanu sarežģītu. Formatēšana atjauno lasāmību pārskatīšanai un rediģēšanai.
• Nesakārtota atkāpe: JSON, kas ielikts no dažādiem avotiem, var saturēt sajauktas tabulācijas, atstarpes vai dažādas atkāpes dziļumus. Pārformatēšana normalizē šīs atšķirības, uzlabojot skaidrību un vienotību.
• Lielas/dziļi iegultas struktūras: Dziļi iegultas masīvi vai objekti (piemēram, konfigurācijas faili vai sarežģītas API atbildes) kļūst viegli pārskatāmi un pārvietojami, kad tie ir formatēti ar rediģētājiem, kas atbalsta sakļaušanu.

Reālas dzīves piemērs: API atbilžu formatēšana

Integrējoties ar trešo pušu API (piemēram, AWS, Stripe vai Google Cloud), atbildes bieži tiek kompakti veidotas ātruma dēļ. JSON formatēšana padara to vieglāk pārbaudāmu, lai atrastu trūkstošas lauciņus, atkļūdot negaidītās vērtības vai kopīgojot ar komandas biedriem.

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

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

Kā izmantot šo rīku JSON formatēšanai

1. Ielīmējiet vai augšupielādējiet savu neapstrādāto, minimizēto vai slikti formatēto JSON ievades laukā.
2. Izvēlieties formatēšanas iespējas (atkāpes izmērs, atslēgu kārtošana utt.).
3. Noklikšķiniet uz “Formatēt”, lai apstrādātu ievadi.
4. Skatiet vai kopējiet tīru, viegli lasāmu rezultātu. Ja tiek atrastas kļūdas, parādīsies detalizēti sintakses ziņojumi, kas palīdzēs JSON labošanā.

Visa formatēšana tiek veikta droši jūsu pārlūkprogrammā — dati nekad neiziet no jūsu ierīces.

JSON formatēšanas koda piemēri

Skatiet, kā formatēt JSON dažādās programmēšanas valodās. Šie piemēri ilustrē pamata formatēšanas paņēmienus.

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