JSON Форматиращ инструмент

Какво е форматиране на JSON?

Форматирането на JSON е процесът на преобразуване на JSON данни в последователно, четимо за хора представяне чрез добавяне на отстъпи, интервали и нови редове — без промяна на структурата или съдържанието му. Правилното форматиране улеснява инспекцията, отстраняването на грешки, споделянето и редактирането, като същевременно осигурява съвместимост с машини и софтуерни инструменти.

По дефиниция JSON игнорира интервалите извън текстовите стойности. Въпреки това, лошо форматираният (или минифициран) JSON — без отстъпи или на един ред — може да бъде почти невъзможен за четене или надеждна модификация от хора.

Форматиране срещу минифициране на JSON

• Форматирането добавя интервали, отстъпи и нови редове за ясност и по-добра четимост.
• Минифицирането премахва всички ненужни интервали за максимална компактност и ефективност при съхранение или трансфер.
• Мощен JSON форматиращ инструмент ви позволява да превключвате между тези режими, улеснявайки преминаването от четими за хора към оптимизирани за машина версии когато е необходимо.

Пример: Минифициран срещу форматиран 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
}

Защо да форматираме JSON?

• Четимост: Подходящите отстъпи и нови редове улесняват инспекцията на вложени обекти, откриването на грешки и разбирането на сложни структури с един поглед.
• Отстраняване на грешки: Отстраняването на проблеми с невалидни или непредвидени данни е много по-лесно, когато можете визуално да прегледате и проследите ключове, стойности и вложеност.
• Сътрудничество: Добре форматиран JSON е по-лесен за преглед, обсъждане и редактиране в кодови ревюта, документация или споделени файлове.
• Контрол на версиите: Git и други инструменти за управление на версии произвеждат по-смислени разлики с форматиран JSON, което улеснява проследяването на промени във времето.
• Съответствие: Много стилови указания и автоматични линтери (като Prettier, ESLint или jq) налагат последователно форматиране за яснота и стандартизация.
• Съвместимост с инструменти: Някои API, CLI и редактори очакват форматиран вход за по-лесно човешко взаимодействие или логване.

Как работи JSON форматиращ инструмент?

1. Анализиране: Форматиращият инструмент първо се опитва да анализира вашия входен текст с помощта на стриктен JSON парсер. Тази стъпка проверява валидността на синтаксиса — улавяйки проблеми като липсващи кавички, запетаи накрая или неексплоатирани знаци.
2. Красиво отпечатване: След като е валиден, анализираните данни се сериализират обратно в текст със зададените от потребителя отстъпи (обикновено 2 или 4 интервала) и нови редове, създавайки "красиво отпечатана" версия.

Ако входът не е валиден JSON, форматиращият инструмент ще хвърли грешка или ще предостави полезно съобщение с местоположение и причина на проблема.

Опции за форматиране

• Отстъпи: Задайте броя на интервалите на ниво (до 8).
• Сортирай ключовете на обекти по азбучен ред
• Използвай табулации вместо интервали за отстъпи
• Ескейпни не-ASCII знаци като Unicode
• Минифицирай изхода (на един ред, без интервали)

Чести проблеми, решени чрез форматиране

• JSON на един ред/минифициран: Данни от API или логове често се минифицират за по-голяма ефективност, което затруднява ръчното редактиране. Форматирането възстановява четимостта за преглед и редакция.
• Несъответстващи отстъпи: JSON, поставен от различни източници, може да съдържа смесени табулации, интервали или различна дълбочина на отстъпи. Форматирането нормализира тези различия, подобрявайки яснота и последователност.
• Големи/вложени структури: Дълбоко вложени масиви или обекти (като конфигурационни файлове или сложни API отговори) стават по-лесни за навигация, когато са форматирани, с възможност за свиване във поддържани редактори.

Реален случай: форматиране на API отговори

При интеграция с трети страни API (като AWS, Stripe или Google Cloud), отговорите често са компактизирани за бързина. Форматирането на JSON улеснява инспекцията за липсващи полета, отстраняване на неочаквани стойности и споделяне с екипа.

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

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

Как да форматирате JSON с този инструмент

1. Поставете или качете своя суров, минифициран или лошо форматиран JSON в полето за въвеждане.
2. Изберете опции за форматиране (размер на отстъпа, сортиране на ключове и др.).
3. Натиснете „Форматирай“, за да обработите своя вход.
4. Прегледайте или копирайте чистия, четим резултат. Ако бъдат открити грешки, ще се появят детайлни съобщения за синтаксиса, които да ви помогнат да поправите JSON-а.

Всички форматирания се извършват сигурно в браузъра – вашите данни никога не напускат устройството ви.

Примери с код за форматиране на JSON

Вижте как да форматирате JSON в различни програмни езици. Тези примери демонстрират основни техники за форматиране.

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