JSON to Go Struct

JSON से Go रूपांतरण क्या है?

JSON से Go रूपांतरण वह प्रक्रिया है जिसमें कच्चे JSON डेटा को Go के standard library के encoding/json पैकेज के साथ काम करने वाली Go प्रकार परिभाषाओं में बदला जाता है। Go एक statically typed भाषा है, इसलिए प्रत्येक JSON फ़ील्ड के लिए एक संगत struct फ़ील्ड चाहिए जिसमें सही प्रकार और एक struct टैग हो जो serializer को बताए कि किस JSON कुंजी से मैपिंग करनी है। बड़ी या गहरी नेस्टेड API प्रतिक्रियाओं के लिए ये परिभाषाएँ हाथ से लिखना धीमा और त्रुटि-प्रवण होता है।

encoding/json पैकेज, जो Go 1.0 से Go विनिर्देशन में परिभाषित है, JSON कुंजियों को निर्यातित struct फ़ील्ड से मिलाने के लिए reflection का उपयोग करता है। यह मिलान डिफ़ॉल्ट रूप से case-insensitive होता है, परंतु स्पष्ट json struct टैग मानक प्रचलन है क्योंकि वे अस्पष्टता दूर करते हैं और आपको Go की PascalCase परंपरा बनाए रखने देते हैं जबकि JSON camelCase या snake_case में रहता है। एक कनवर्टर यह सब स्वचालित करता है: वह आपका JSON पढ़ता है, मानों से Go प्रकार अनुमानित करता है और सही टैग के साथ struct परिभाषाएँ आउटपुट करता है।

Go का type system JSON पर अच्छी तरह मैप होता है। स्ट्रिंग string बनती है, बूलियन bool बनता है, पूर्णांक int बनते हैं और दशमलव संख्याएँ float64 बनती हैं। नेस्टेड JSON ऑब्जेक्ट अलग-अलग नाम वाले struct बनते हैं और ऐरे स्लाइस बनते हैं। एकमात्र अपवाद null है: Go में कोई सार्वभौमिक nullable प्रकार नहीं है, इसलिए null मान सामान्यतः पॉइंटर प्रकार (*string, *int) या interface{} बनते हैं। एक जनरेटर यह सब कुछ ही मिलीसेकंड में संभाल लेता है।

JSON to Go कनवर्टर का उपयोग क्यों करें?

JSON से Go struct हाथ से परिभाषित करने का अर्थ है curly braces गिनना, types का अनुमान लगाना और हर बार API बदलने पर टैग फिर से लिखना। एक कनवर्टर यह सब कार्य समाप्त कर देता है।

JSON to Go के उपयोग के मामले

JSON से Go प्रकार मैपिंग

encoding/json पैकेज JSON मानों को Go प्रकारों से मैप करते समय विशिष्ट नियमों का पालन करता है। नीचे दी गई तालिका डिफ़ॉल्ट मैपिंग और सामान्य विकल्प दर्शाती है। "डिफ़ॉल्ट" स्तंभ वह है जो अधिकांश जनरेटर उत्पन्न करते हैं। "विकल्प" स्तंभ वे प्रकार दर्शाता है जो आप अपनी आवश्यकताओं के आधार पर चुन सकते हैं, जैसे बड़े आईडी के लिए int64 या nullable फ़ील्ड के लिए पॉइंटर प्रकार।

Go JSON Struct टैग संदर्भ

Struct टैग नियंत्रित करते हैं कि encoding/json फ़ील्ड को कैसे marshal और unmarshal करता है। json टैग अब तक सबसे सामान्य है, लेकिन आप इसे एक ही फ़ील्ड पर अन्य टैग (db, yaml, xml) के साथ मिला सकते हैं। टैग का syntax फ़ील्ड type के बाद backtick string होती है। encoding/json द्वारा समर्थित json टैग विकल्प यहाँ दिए गए हैं।

json.Unmarshal बनाम json.NewDecoder

Go JSON डीकोड करने के दो तरीके प्रदान करता है: बाइट स्लाइस के लिए json.Unmarshal और io.Reader स्ट्रीम के लिए json.NewDecoder। दोनों एक ही struct टैग नियम उपयोग करते हैं, लेकिन उनके उपयोग के समय में अंतर है।

कोड उदाहरण

ये उदाहरण दर्शाते हैं कि JSON से जनरेट किए गए Go struct को वास्तविक कार्यक्रमों में कैसे उपयोग करें, साथ ही उन्हें अन्य भाषाओं से कैसे जनरेट करें। Go उदाहरण standard library से encoding/json उपयोग करते हैं।

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	ID       int      `json:"id"`
	Name     string   `json:"name"`
	Email    string   `json:"email"`
	IsActive bool     `json:"is_active"`
	Tags     []string `json:"tags"`
}

func main() {
	data := []byte(`{"id":1,"name":"Alice","email":"alice@example.com","is_active":true,"tags":["admin","editor"]}`)

	var user User
	if err := json.Unmarshal(data, &user); err != nil {
		panic(err)
	}
	fmt.Println(user.Name)  // → Alice
	fmt.Println(user.Tags)  // → [admin editor]
}

// JSON response from API — this is the shape you'd convert to Go:
const res = await fetch("https://api.example.com/users/1");
const user = await res.json();
// user → { "id": 1, "name": "Alice", "email": "alice@example.com" }

// Equivalent Go struct:
// type User struct {
//     ID    int    `json:"id"`
//     Name  string `json:"name"`
//     Email string `json:"email"`
// }

import json

def json_to_go(data: dict, name: str = "Root") -> str:
    lines = [f"type {name} struct {{"]
    type_map = {str: "string", int: "int", float: "float64", bool: "bool"}

    for key, value in data.items():
        go_type = type_map.get(type(value), "interface{}")
        field = key.title().replace("_", "")  # snake_case → PascalCase
        lines.append(f'\t{field} {go_type} `json:"{key}"`')
    lines.append("}")
    return "\n".join(lines)

data = json.loads('{"user_name": "Alice", "age": 30, "verified": true}')
print(json_to_go(data))
# type Root struct {
#     UserName string `json:"user_name"`
#     Age      int    `json:"age"`
#     Verified bool   `json:"verified"`
# }

package main

import (
	"encoding/json"
	"fmt"
	"strings"
)

type Event struct {
	Type    string `json:"type"`
	Payload string `json:"payload"`
}

func main() {
	stream := strings.NewReader(`{"type":"click","payload":"btn-1"}
{"type":"scroll","payload":"page-2"}`)

	dec := json.NewDecoder(stream)
	for dec.More() {
		var ev Event
		if err := dec.Decode(&ev); err != nil {
			break
		}
		fmt.Printf("%s: %s\n", ev.Type, ev.Payload)
	}
	// → click: btn-1
	// → scroll: page-2
}

अक्सर पूछे जाने वाले प्रश्न