Go में JSON को खूबसूरती से प्रिंट करें: पूरी गाइड उदाहरणों के साथ

Go में JSON गड़बड़ क्यों दिखता है और इसे कैसे ठीक करें?

क्या आपने कभी Go में ऐसा प्रोग्राम लिखा है जो JSON आउटपुट करता है, और टर्मिनल में कुछ ऐसा दिखा?

{"name":"PythonLib","year":2025,"tags":["go","json","tutorial"],"active":true}

माना, बिना किसी विशेष टूल के इसे पढ़ना मज़ेदार नहीं है। खासकर जब डेटा स्ट्रक्चर जटिल हो और नेस्टिंग कई लेवल तक चली जाए। आँखें भटकने लगती हैं और सही फील्ड ढूँढना एक चुनौती बन जाता है।

अच्छी खबर: Go में बिल्ट-इन सुविधाएँ हैं जो इस 'गड़बड़' को एक साफ-सुथरे, संरचित दस्तावेज़ में बदल देती हैं। आज हम JSON को खूबसूरती से फॉर्मेट करने के सभी तरीकों पर चर्चा करेंगे - स्टैंडर्ड लाइब्रेरी के सरल उपयोग से लेकर अपना खुद का pretty-print टूल बनाने तक।

यह सामग्री Stack Overflow के एक वास्तविक प्रश्न (50,000 से अधिक व्यूज़) पर आधारित है, इसलिए यह विषय वास्तव में लोकप्रिय है। चलिए शुरू करते हैं!

Pretty-print क्या है और इसकी आवश्यकता क्यों है?

Pretty-print (या 'सुंदर प्रिंट') डेटा को इंडेंटेशन, लाइन ब्रेक और अलाइनमेंट के साथ फॉर्मेट करना है ताकि इसे मनुष्य आसानी से पढ़ सके। JSON के संदर्भ में, इसका मतलब है:

\n
• नेस्टेड एलिमेंट्स के लिए स्पेस या टैब जोड़ना
\n
• प्रत्येक 'की-वैल्यू' जोड़ी को एक नई लाइन पर लाना
\n
• स्पष्टता के लिए वैल्यू को अलाइन करना
\n

Go में इसकी आवश्यकता क्यों है? कल्पना करें कि आप API रिस्पॉन्स को डीबग कर रहे हैं, लॉगर लिख रहे हैं, या सिर्फ कॉन्फ़िगरेशन आउटपुट कर रहे हैं। अनफ़ॉर्मेटेड JSON कम जगह लेता है, लेकिन पढ़ने योग्य नहीं होता। Pretty-print कोड की कुछ पंक्तियों में इस समस्या को हल करता है।

तरीका 1: json.MarshalIndent — मानक समाधान

सबसे सरल और अनुशंसित तरीका है json.MarshalIndent फंक्शन का उपयोग करना, जो स्टैंडर्ड पैकेज encoding/json से आता है। यह बिल्कुल वही करता है जो आपको चाहिए: डेटा लेता है और इंडेंटेशन के साथ फ़ॉर्मेटेड JSON लौटाता है।

यहाँ एक बुनियादी उदाहरण है:

package main\n\nimport (\n    "encoding/json"\n    "fmt"\n    "log"\n)\n\ntype Site struct {\n    Name   string   `json:"name"`\n    Year   int      `json:"year"`\n    Tags   []string `json:"tags"`\n    Active bool     `json:"active"`\n}\n\nfunc main() {\n    site := Site{\n        Name:   "PythonLib",\n        Year:   2025,\n        Tags:   []string{"go", "json", "tutorial"},\n        Active: true,\n    }\n\n    // प्रीफिक्स — "", इंडेंट — "  " (दो स्पेस)\n    prettyJSON, err := json.MarshalIndent(site, "", "  ")\n    if err != nil {\n        log.Fatalf("मार्शलिंग में त्रुटि: %v", err)\n    }\n\n    fmt.Println(string(prettyJSON))\n}

परिणाम:

{\n  "name": "PythonLib",\n  "year": 2025,\n  "tags": [\n    "go",\n    "json",\n    "tutorial"\n  ],\n  "active": true\n}

सुंदर है, है ना? MarshalIndent के दूसरे और तीसरे पैरामीटर पर ध्यान दें:

\n
• प्रीफिक्स — एक स्ट्रिंग जो प्रत्येक लाइन की शुरुआत में जोड़ी जाती है। आमतौर पर खाली स्ट्रिंग ""।
\n
• इंडेंट — नेस्टिंग के प्रत्येक स्तर के लिए स्ट्रिंग। अक्सर दो स्पेस " " या टैब "\\t" का उपयोग किया जाता है।
\n

इंडेंटेशन सेट करना: स्पेस बनाम टैब

आप इंडेंटेशन स्टाइल को आसानी से बदल सकते हैं। उदाहरण के लिए, टैब के साथ:

prettyJSON, _ := json.MarshalIndent(site, "", "\\t")\nfmt.Println(string(prettyJSON))

परिणाम:

{\n\t"name": "PythonLib",\n\t"year": 2025,\n\t"tags": [\n\t\t"go",\n\t\t"json",\n\t\t"tutorial"\n\t],\n\t"active": true\n}

कौन सा विकल्प चुनें? यदि आपका प्रोजेक्ट Go मानकों का पालन करता है (जो कोड के लिए टैब की सलाह देते हैं), तो "\\t" का उपयोग करें। यदि आप एक टीम में काम करते हैं जहाँ स्पेस का उपयोग होता है, तो दो स्पेस उपयुक्त रहेंगे। मुख्य बात एकरूपता है।

तरीका 2: कच्चे JSON स्ट्रिंग के लिए Pretty-print

क्या होगा यदि आपके पास पहले से ही एक अनफ़ॉर्मेटेड JSON स्ट्रिंग है?