JSON फ़ॉर्मेटर

JSON फ़ॉर्मेटिंग क्या है?

JSON फ़ॉर्मेटिंग वह प्रक्रिया है जिसमें JSON डेटा को एक सुसंगत, मानव-पठनीय रूप में परिवर्तित किया जाता है, जिसमें इंडेंटेशन, व्हाइटस्पेस, और लाइन ब्रेक जोड़े जाते हैं—बिना उसके संरचना या सामग्री को बदले। उचित फ़ॉर्मेटिंग JSON को निरीक्षण, डिबग, साझा और संपादित करना आसान बनाती है जबकि मशीनों और सॉफ़्टवेयर टूल्स के साथ संगतता सुनिश्चित करती है।

परिभाषा के अनुसार JSON स्ट्रिंग मानों के बाहर व्हाइटस्पेस को नजरअंदाज करता है। हालांकि, खराब फ़ॉर्मेट किया गया (या मिनिफ़ाई किया गया) JSON—जिसमें इंडेंटेशन नहीं होता या सब कुछ एक लाइन में होता है—इसे मनुष्यों के लिए पढ़ना या विश्वसनीय रूप से संशोधित करना लगभग नामुमकिन हो जाता है।

JSON का फ़ॉर्मेटिंग vs. मिनिफ़ाई करना

• फ़ॉर्मेटिंग स्पष्टता और पठनीयता के लिए व्हाइटस्पेस, इंडेंटेशन और लाइन ब्रेक जोड़ता है।
• मिनिफ़ाई करना अधिकतम संकुचन और संग्रहण या ट्रांसफर की दक्षता के लिए सभी अनावश्यक व्हाइटस्पेस को हटाता है।
• एक सशक्त JSON फ़ॉर्मेटर आपको इन मोड्स के बीच स्विच करने देता है, जिससे मानव-मैत्रीपूर्ण और मशीन-उन्मुख संस्करणों के बीच आसानी से टॉगल कर सकते हैं।

उदाहरण: मिनिफ़ाईड vs. फॉर्मेटेड 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) स्पष्टता और मानकीकरण के लिए सुसंगत फ़ॉर्मेटिंग लागू करते हैं।
• टूल संगतता: कुछ APIs, CLIs, और संपादक मानव इंटरैक्शन या लॉगिंग के लिए फ़ॉर्मेटेड इनपुट की अपेक्षा करते हैं।

JSON फ़ॉर्मेटर कैसे काम करता है?

1. पार्सिंग: फ़ॉर्मेटर पहले आपके इनपुट टेक्स्ट को कड़ाई से JSON पार्सर के द्वारा पार्स करता है। यह चरण सिंटैक्स की वैधता जांचता है—जैसे ग़ायब कोट्स, अतिरिक्त कॉमा, या गैर-एस्केप्ड कैरेक्टर्स।
2. सुंदर प्रिंटिंग: एक बार मान्य हो जाने पर, पार्स किए गए डेटा को उपयोगकर्ता-निर्धारित इंडेंटेशन (आमतौर पर 2 या 4 स्पेस) और लाइन ब्रेक के साथ फिर से स्ट्रिंग में बदला जाता है, जिससे "सुंदर प्रिंटेड" संस्करण बनता है।

यदि इनपुट वैध JSON नहीं है, तो फ़ॉर्मेटर त्रुटि देगा या समस्या के स्थान और प्रकार को बताने वाला सहायक संदेश देगा।

फ़ॉर्मेटिंग विकल्प

• इंडेंटेशन: स्तर प्रति स्पेसेस की संख्या सेट करें (अधिकतम 8)।
• ऑब्जेक्ट कीज़ को वर्णानुक्रम में क्रमबद्ध करें
• स्पेस की बजाय इंडेंटेशन के लिए टैब का उपयोग करें
• गैर-ASCII कैरेक्टर्स को यूनिकोड के रूप में एस्केप करें
• आउटपुट को मिनिफ़ाई करें (एक लाइन, बिना स्पेसेस)

फ़ॉर्मेटिंग से हल होने वाली सामान्य समस्याएं

• सिंगल-लाइन/मिनिफ़ाईड JSON: API या लॉग फ़ाइलों से आया डेटा अक्सर बैंडविड्थ बचाने के लिए मिनिफ़ाई किया जाता है, जिससे मैनुअल संपादन मुश्किल हो जाता है। फ़ॉर्मेटिंग समीक्षा और संपादन के लिए पठनीयता बहाल करती है।
• असंगत इंडेंटेशन: विभिन्न स्रोतों से कॉपी किए गए JSON में टैब, स्पेस या इंडेंटेशन की गहराई मिश्रित हो सकती है। पुनः फ़ॉर्मेटिंग इन असंगतियों को सामान्य करती है, जिससे स्पष्टता और एकरूपता बेहतर होती है।
• बड़ी/नेस्टेड संरचनाएं: गहरा नेस्टेड एरे या ऑब्जेक्ट्स (जैसे कॉन्फ़िगरेशन फ़ाइलें या जटिल API प्रतिक्रियाएं) फॉर्मेटिंग से आसान और संकुचित व्यू के साथ नेविगेट करने योग्य बन जाते हैं।

वास्तविक उपयोग मामला: API प्रतिक्रियाओं का फ़ॉर्मेटिंग

जब तृतीय-पक्ष APIs (जैसे 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 को कैसे फॉर्मेट करें। ये उदाहरण बुनियादी फॉर्मेटिंग तकनीकों को दिखाते हैं।

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