JSON स्वरूपक

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 आणि इतर VCS टूल्स योग्य स्वरूपित JSON सह अधिक अर्थपूर्ण फरक तयार करतात, ज्यामुळे बदलांचा मागोवा घेणे सोपे होते.
• अनुपालन: अनेक शैली मार्गदर्शक आणि स्वयंचलित लिंटर्स (Prettier, ESLint, jq सारखे) स्पष्टता आणि मानकीकरणासाठी सुसंगत स्वरूपन लागू करतात.
• साधन सुसंगतता: काही API, CLI आणि संपादकांसाठी माणूस-सुलभ इंटरॅक्शन किंवा लॉगिंगसाठी स्वरूपित इनपुट अपेक्षित असतो.

JSON स्वरूपक कसे काम करते?

1. पार्सिंग: स्वरूपक आतल्या टेक्स्टला कडक JSON पार्सरने पार्स करण्याचा प्रयत्न करते. यामुळे चिन्हशैलीची वैधता तपासली जाते — जसे की गप्पांच्या चिन्हांचा अभाव, शेवटी कॉमा, किंवा एस्केप न झालेली चिन्हे.
2. सुंदर छपाई: एकदा वैध झाल्यावर, पार्स केलेला डेटा वापरकर्त्याने ठरवलेल्या इंडेंटेशन (साधारणपणे २ किंवा ४ स्पेसेस) आणि लाइन ब्रेक्ससह पुन्हा स्ट्रिंगमध्ये रूपांतरित केला जातो, ज्यामुळे "सुंदर छापलेली" आवृत्ती तयार होते.

जर इनपुट वैध JSON नसेल, तर स्वरूपक त्रुटी फेकते किंवा त्रुटीचा ठिकाण आणि प्रकार दर्शवणारा मदत करणारा संदेश देते.

स्वरूपन पर्याय

• इंडेंटेशन: स्तर विरोधी स्पेसेसची संख्या ठरवा (जास्तीत जास्त ८).
• ऑब्जेक्ट कीज वर्णक्रमानुसार क्रमवारी लावा
• स्पेसेसऐवजी इंडेंटेशनसाठी टॅब वापरा
• अ-ASCII वर्ण युनिकोड स्वरूपात एस्केप करा
• आउटपुट मिनिफाय करा (एकच ओळ, स्पेसेसशिवाय)

स्वरूपनाद्वारे सोडवलेल्या सामान्य समस्या

• सिंगल लाइन/मिनिफाय 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)
}