JSON स्वरूपक

इस सरल उपकरण के साथ अपने JSON को स्वरूपित और सुंदर बनाएं

कच्चा JSON इनपुट*

स्वरूपित JSON आउटपुट

स्वरूपित JSON यहां दिखाई देगा...

JSON Formatter

परिचय

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

JSON फॉर्मेटिंग (जिसे "सुंदर प्रिंटिंग" भी कहा जाता है) संकुचित, मिनिफाइड JSON में सुसंगत इंडेंटेशन, लाइन ब्रेक और स्पेसिंग जोड़ता है ताकि JSON डेटा की पदानुक्रमिक संरचना दृश्य रूप से स्पष्ट हो सके। यह विशेष रूप से जटिल नेस्टेड ऑब्जेक्ट्स या बड़े डेटा सेट्स के साथ काम करते समय मूल्यवान होता है जहां तत्वों के बीच के संबंध अन्यथा समझना कठिन हो सकता है।

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

JSON सिंटैक्स और संरचना

JSON दो प्राथमिक संरचनाओं पर आधारित है:

ऑब्जेक्ट्स: कर्ली ब्रेसेस {} में बंद नाम/मूल्य जोड़े का संग्रह। प्रत्येक नाम के बाद एक कॉलन : होता है और जोड़े को कॉमा , द्वारा अलग किया जाता है।

   {"name": "John", "age": 30, "city": "New York"}

एरेज़: वर्ग ब्रेकेट्स [] में बंद मूल्यों की क्रमबद्ध सूची। मूल्यों को कॉमा , द्वारा अलग किया जाता है।

   ["apple", "banana", "cherry"]

JSON मान हो सकते हैं:

स्ट्रिंग्स (डबल कोट्स में): "Hello World"
नंबर: 42 या 3.14159
बूलियन्स: true या false
नल: null
ऑब्जेक्ट्स: {"key": "value"}
एरेज़: [1, 2, 3]

सही JSON को इन सिंटैक्स नियमों का पालन करना चाहिए:

नाम डबल कोट्स में स्ट्रिंग्स होने चाहिए
मानों को एक मान्य JSON डेटा प्रकार में से एक होना चाहिए
कोई ट्रेलिंग कॉमा नहीं होना चाहिए
कोई टिप्पणी की अनुमति नहीं है
कोई फ़ंक्शन या विधियाँ नहीं होनी चाहिए

सामान्य सिंटैक्स त्रुटियों में शामिल हैं:

गायब या असंगत ब्रैकेट/ब्रैस
प्रॉपर्टी नामों के चारों ओर गायब कोट्स
प्रॉपर्टी नामों के लिए सिंगल कोट्स का उपयोग करना
ट्रेलिंग कॉमा शामिल करना
मान के रूप में अनिर्धारित का उपयोग करना

JSON फॉर्मेटिंग कैसे काम करती है

JSON फॉर्मेटिंग संकुचित, मिनिफाइड JSON को एक अधिक पढ़ने योग्य रूप में परिवर्तित करती है:

पार्सिंग: सबसे पहले JSON स्ट्रिंग को पार्स किया जाता है ताकि यह सुनिश्चित हो सके कि यह मान्य है और डेटा संरचना का एक इन-मेमोरी प्रतिनिधित्व बनाया जा सके।
इंडेंटेशन: ऑब्जेक्ट्स और एरेज़ के प्रत्येक नेस्टेड स्तर को दृश्य रूप से पदानुक्रम को दर्शाने के लिए इंडेंट किया जाता है (आमतौर पर 2 या 4 स्पेस द्वारा)।
लाइन ब्रेक्स: प्रत्येक प्रॉपर्टी या एरे तत्व के बाद नई लाइनों को जोड़ा जाता है ताकि पढ़ने में आसानी हो सके।
स्पेसिंग: कॉलन और कॉमा के चारों ओर सुसंगत स्पेसिंग जोड़ी जाती है।

उदाहरण के लिए, यह मिनिफाइड JSON:

{"name":"John Doe","age":30,"address":{"street":"123 Main St","city":"Anytown","state":"CA"},"hobbies":["reading","hiking","photography"]}

इस फॉर्मेटेड JSON में बदल जाता है:

{
  "name": "John Doe",
  "age": 30,
  "address": {
    "street": "123 Main St",
    "city": "Anytown",
    "state": "CA"
  },
  "hobbies": [
    "reading",
    "hiking",
    "photography"
  ]
}

हमारा फॉर्मेटर प्रति स्तर 2 स्पेस की मानक इंडेंटेशन का उपयोग करता है, जो विकास समुदाय में एक सामान्य प्रथा है और संक्षिप्तता और पढ़ने में आसानी के बीच एक अच्छा संतुलन प्रदान करता है।

JSON वैलिडेशन

JSON फॉर्मेटिंग का एक महत्वपूर्ण पहलू वैलिडेशन है। JSON को फॉर्मेट करने से पहले, इसे JSON विनिर्देशन के अनुसार सिंटैक्स रूप से मान्य होना चाहिए। सामान्य वैलिडेशन त्रुटियों में शामिल हैं:

सिंटैक्स त्रुटियाँ:
- अनकोटेड प्रॉपर्टी नाम
- गायब या अतिरिक्त कॉमा
- गलत तरीके से नेस्टेड संरचनाएँ
- अनक्लोज़्ड स्ट्रिंग्स, ऑब्जेक्ट्स, या एरेज़
डेटा प्रकार त्रुटियाँ:
- बहुत बड़े पूर्णांकों या फ्लोटिंग-पॉइंट मानों के लिए संख्या की सटीकता खोना
- स्ट्रिंग्स के रूप में सटीक संख्या मानों का उपयोग करना
- चरित्रों और एस्केप अनुक्रमों के साथ सावधान रहना
- सभी मूल चरित्रों को बनाए रखने के लिए फॉर्मेटेड आउटपुट का सत्यापन करना

जब आप अमान्य JSON का सामना करते हैं, तो त्रुटि संदेश समस्या की पहचान करने में मदद कर सकता है। अधिकांश JSON पार्सर्स यह बताएंगे कि पार्सिंग विफल होने का स्थान कहाँ है, जो समस्या को पहचानने में मदद कर सकता है। हमारा उपकरण आपको JSON डेटा में समस्याओं की पहचान और समाधान करने में मदद करने के लिए स्पष्ट त्रुटि संदेश प्रदान करता है।

उपयोग के मामले

JSON फॉर्मेटिंग कई परिदृश्यों में मूल्यवान है:

एपीआई विकास और परीक्षण

जब RESTful एपीआई के साथ काम करते समय, फॉर्मेटेड JSON इसे आसान बनाता है:

प्रतिक्रिया पेलोड का निरीक्षण करना
अनुरोध निकाय को डिबग करना
एपीआई उदाहरणों को दस्तावेज़ित करना
डेटा संरचनाओं का सत्यापन करना

कॉन्फ़िगरेशन प्रबंधन

कई आधुनिक अनुप्रयोग JSON का उपयोग कॉन्फ़िगरेशन के लिए करते हैं:

अनुप्रयोग सेटिंग फ़ाइलें
पर्यावरण कॉन्फ़िगरेशन
निर्माण और तैनाती विशिष्टताएँ
इन्फ्रास्ट्रक्चर एज़ कोड टेम्पलेट्स (जैसे, AWS CloudFormation, Terraform)

डेटा विश्लेषण और दृश्यता

फॉर्मेटेड JSON तब मदद करता है जब:

डेटा सेट्स का अन्वेषण करना
दृश्यता के लिए डेटा तैयार करना
डेटा स्कीमा को समझना
संरचित डेटा में पैटर्न की पहचान करना

डिबगिंग और समस्या निवारण

सही तरीके से फॉर्मेटेड JSON तब आवश्यक है जब:

वेब अनुप्रयोगों को डिबग करना
localStorage या sessionStorage का निरीक्षण करना
नेटवर्क प्रतिक्रियाओं का विश्लेषण करना
डेटा एकीकरण समस्याओं का समाधान करना

शैक्षिक उद्देश्यों

स्पष्ट JSON फॉर्मेटिंग शिक्षण के लिए मूल्यवान है:

डेटा संरचनाओं को सिखाना
नेस्टेड संबंधों को प्रदर्शित करना
एपीआई अवधारणाओं को समझाना
डेटा मॉडलिंग सिद्धांतों को स्पष्ट करना

विकल्प

हालांकि हमारा वेब-आधारित JSON फॉर्मेटर त्वरित फॉर्मेटिंग कार्यों के लिए सुविधाजनक है, विभिन्न परिदृश्यों के लिए कई विकल्प मौजूद हैं:

ब्राउज़र डेवलपर टूल्स

आधुनिक ब्राउज़र JSON फॉर्मेटिंग क्षमताओं को शामिल करते हैं:

क्रोम और एज डेवलपर टूल्स नेटवर्क टैब में JSON प्रतिक्रियाओं को स्वचालित रूप से फॉर्मेट करते हैं
फ़ायरफ़ॉक्स का JSON व्यूअर इंटरैक्टिव ट्री दृश्य प्रदान करता है
JSONView जैसी ब्राउज़र एक्सटेंशन JSON को सीधे ब्राउज़र में फॉर्मेट कर सकते हैं

कोड संपादक और IDEs

अधिकांश विकास वातावरण JSON फॉर्मेटिंग प्रदान करते हैं:

विजुअल स्टूडियो कोड में अंतर्निहित JSON फॉर्मेटिंग है (Alt+Shift+F)
जेटब्रेन IDEs (वेबस्टॉर्म, इंटेलीज़) में शक्तिशाली JSON उपकरण शामिल हैं
सबलाइम टेक्स्ट और एटम प्लगइन्स के माध्यम से JSON फॉर्मेटिंग का समर्थन करते हैं

कमांड लाइन टूल्स

टर्मिनल उपयोगकर्ताओं या स्वचालन के लिए:

jq एक शक्तिशाली कमांड-लाइन JSON प्रोसेसर है
json_pp कई यूनिक्स सिस्टम पर पूर्व-स्थापित आता है
python -m json.tool JSON का त्वरित फॉर्मेटिंग प्रदान करता है

प्रोग्रामेटिक दृष्टिकोण

जब अनुप्रयोगों के भीतर JSON को फॉर्मेट करना:

// जावास्क्रिप्ट
const formatted = JSON.stringify(jsonObject, null, 2);

# पायथन
import json
formatted = json.dumps(json_object, indent=2)

// जावा विद ग्सन
Gson gson = new GsonBuilder().setPrettyPrinting().create();
String formatted = gson.toJson(jsonObject);

# रूबी
require 'json'
formatted = JSON.pretty_generate(json_object)

// PHP
$formatted = json_encode($jsonObject, JSON_PRETTY_PRINT);

इतिहास

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

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

JSON की स्वीकृति AJAX और RESTful एपीआई के उदय के साथ 2000 के दशक के मध्य में तेज़ी से बढ़ी। 2010 के दशक तक, यह वेब एपीआई, कॉन्फ़िगरेशन फ़ाइलों और NoSQL डेटाबेस जैसे MongoDB और CouchDB में डेटा स्टोरेज के लिए मानक बन गया था।

आज, JSON को लगभग हर प्रोग्रामिंग भाषा द्वारा समर्थित किया जाता है और यह वेब पर अनगिनत अनुप्रयोगों में उपयोग किया जाता है। इसकी सरलता, लचीलापन और सार्वभौमिक समर्थन ने इसे आधुनिक कंप्यूटिंग में सबसे महत्वपूर्ण डेटा प्रारूपों में से एक बना दिया है।

कोड उदाहरण

यहाँ विभिन्न प्रोग्रामिंग भाषाओं में JSON को फॉर्मेट करने के उदाहरण दिए गए हैं:

// जावास्क्रिप्ट JSON फॉर्मेटिंग
function formatJSON(jsonString) {
  try {
    const parsedData = JSON.parse(jsonString);
    return JSON.stringify(parsedData, null, 2);
  } catch (error) {
    return `त्रुटि: ${error.message}`;
  }
}

// उदाहरण उपयोग
const rawJSON = '{"name":"John","age":30,"city":"New York"}';
console.log(formatJSON(rawJSON));

# पायथन JSON फॉर्मेटिंग
import json

def format_json(json_string):
    try:
        parsed_data = json.loads(json_string)
        return json.dumps(parsed_data, indent=2)
    except json.JSONDecodeError as e:
        return f"त्रुटि: {str(e)}"

# उदाहरण उपयोग
raw_json = '{"name":"John","age":30,"city":"New York"}'
print(format_json(raw_json))

// जावा JSON फॉर्मेटिंग विद ग्सन
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonSyntaxException;

public class JSONFormatter {
    public static String formatJSON(String jsonString) {
        try {
            Gson gson = new GsonBuilder().setPrettyPrinting().create();
            Object parsedJson = gson.fromJson(jsonString, Object.class);
            return gson.toJson(parsedJson);
        } catch (JsonSyntaxException e) {
            return "त्रुटि: " + e.getMessage();
        }
    }
    
    public static void main(String[] args) {
        String rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
        System.out.println(formatJSON(rawJSON));
    }
}

// PHP JSON फॉर्मेटिंग
function formatJSON($jsonString) {
    $result = json_decode($jsonString);
    if (json_last_error() !== JSON_ERROR_NONE) {
        return "त्रुटि: " . json_last_error_msg();
    }
    return json_encode($result, JSON_PRETTY_PRINT);
}

// उदाहरण उपयोग
$rawJSON = '{"name":"John","age":30,"city":"New York"}';
echo formatJSON($rawJSON);

# रूबी JSON फॉर्मेटिंग
require 'json'

def format_json(json_string)
  begin
    parsed_data = JSON.parse(json_string)
    return JSON.pretty_generate(parsed_data)
  rescue JSON::ParserError => e
    return "त्रुटि: #{e.message}"
  end
end

# उदाहरण उपयोग
raw_json = '{"name":"John","age":30,"city":"New York"}'
puts format_json(raw_json)

// C# JSON फॉर्मेटिंग विद न्यूटनसोफ्ट.जेसन
using Newtonsoft.Json;
using System;

class JSONFormatter
{
    public static string FormatJSON(string jsonString)
    {
        try
        {
            object parsedJson = JsonConvert.DeserializeObject(jsonString);
            return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
        }
        catch (JsonException e)
        {
            return $"त्रुटि: {e.Message}";
        }
    }
    
    static void Main()
    {
        string rawJSON = "{\"name\":\"John\",\"age\":30,\"city\":\"New York\"}";
        Console.WriteLine(FormatJSON(rawJSON));
    }
}

// गो JSON फॉर्मेटिंग
package main

import (
    "encoding/json"
    "fmt"
)

func formatJSON(jsonString string) string {
    var parsedData interface{}
    err := json.Unmarshal([]byte(jsonString), &parsedData)
    if err != nil {
        return fmt.Sprintf("त्रुटि: %s", err.Error())
    }
    
    formattedBytes, err := json.MarshalIndent(parsedData, "", "  ")
    if err != nil {
        return fmt.Sprintf("त्रुटि: %s", err.Error())
    }
    
    return string(formattedBytes)
}

func main() {
    rawJSON := `{"name":"John","age":30,"city":"New York"}`
    fmt.Println(formatJSON(rawJSON))
}

किनारे के मामले और विचार

जब JSON फॉर्मेटिंग के साथ काम करते हैं, तो इन संभावित चुनौतियों के प्रति जागरूक रहें:

बड़े JSON फ़ाइलें

बहुत बड़े JSON फ़ाइलें (कई मेगाबाइट या उससे अधिक) ब्राउज़र-आधारित फॉर्मेटर्स में प्रदर्शन समस्याएँ उत्पन्न कर सकती हैं। ऐसे मामलों में:

कमांड-लाइन टूल्स जैसे jq का उपयोग करने पर विचार करें
JSON को छोटे टुकड़ों में विभाजित करें
बिना पूरी फ़ाइल को मेमोरी में लोड किए बिना प्रोसेसिंग के लिए स्ट्रीमिंग पार्सर्स का उपयोग करें

गहरे नेस्टेड संरचनाएँ

अत्यधिक नेस्टेड JSON (10-20 स्तरों से अधिक) को फॉर्मेटेड होने पर भी नेविगेट करना कठिन हो सकता है। ऐसे मामलों में:

यदि संभव हो तो संरचना को समतल करने पर विचार करें
कोलैप्सिबल JSON व्यूअर्स का उपयोग करें
JSON के विशिष्ट अनुभागों के साथ काम करने के लिए निकालें

विशेष वर्ण और यूनिकोड

JSON यूनिकोड का समर्थन करता है, लेकिन कुछ फॉर्मेटर्स कुछ वर्णों के साथ समस्याएँ कर सकते हैं:

सुनिश्चित करें कि आपका फॉर्मेटर इमोजी और अन्य यूनिकोड वर्णों को सही तरीके से संभालता है
नियंत्रण वर्णों और एस्केप अनुक्रमों के साथ सावधान रहें
सत्यापित करें कि फॉर्मेटेड आउटपुट सभी मूल वर्णों को बनाए रखता है

संख्या की सटीकता

JSON संख्या के लिए सटीकता निर्दिष्ट नहीं करता है, जो बहुत बड़े पूर्णांकों या फ्लोटिंग-पॉइंट मानों के साथ समस्याएँ उत्पन्न कर सकता है:

सावधान रहें कि कुछ जावास्क्रिप्ट कार्यान्वयन 53 बिट्स से अधिक पूर्णांकों के लिए सटीकता खो सकते हैं
सटीक संख्या मानों के लिए स्ट्रिंग प्रतिनिधित्व का उपयोग करने पर विचार करें
यदि आपका अनुप्रयोग उच्च सटीकता की आवश्यकता करता है तो चरम मानों के साथ परीक्षण करें

खाली ऑब्जेक्ट्स और एरेज़

मान्य JSON में खाली ऑब्जेक्ट्स {} और एरेज़ [] शामिल होते हैं, जिन्हें सही तरीके से फॉर्मेट किया जाना चाहिए:

खाली ऑब्जेक्ट्स को {} के रूप में प्रकट होना चाहिए
खाली एरेज़ को [] के रूप में प्रकट होना चाहिए
नेस्टेड खाली संरचनाएँ उचित इंडेंटेशन बनाए रखनी चाहिए

संदर्भ

JSON.org - आधिकारिक JSON विनिर्देशन वेबसाइट
RFC 8259 - JSON डेटा इंटरचेंज फॉर्मेट
MDN वेब डॉक्यूमेंटेशन: JSON - जावास्क्रिप्ट में JSON पर व्यापक दस्तावेज़ीकरण
JSON लिंट - एक लोकप्रिय ऑनलाइन JSON वैलिडेटर
jq - एक हल्का और लचीला कमांड-लाइन JSON प्रोसेसर