JSON Toolkit

JSON से Go Struct: जेनरेटर ढाँचा देता है, चार चीज़ें आपके हाथ माँगती हैं

मुख्य बात: कन्वर्टर में एक नमूना API रिस्पॉन्स पेस्ट करें और दस सेकंड में टैग के साथ Go struct आपके पास है — लेकिन संख्याएँ float64 बन जाती हैं, वैकल्पिक फ़ील्ड अपने आप कभी पॉइंटर नहीं बनते, omitempty खाली struct हटा नहीं पाता, और ज़्यादातर तारीखें string ही रहती हैं। पूरा मैपिंग टेबल, पॉइंटर और omitzero के बीच संतुलन, और बने हुए कोड को तैयार करने की चार-चरण की चेकलिस्ट।

मध्यम~6 मिनट पढ़ें2026-11-22 को प्रकाशित2026-11-22 को अपडेट किया गया
ऑनलाइन टूल से JSON नमूने को Go struct कोड में बदलते हुए

पहले निष्कर्ष: कन्वर्टर जो struct दस सेकंड में बनाता है वह कंपाइल हो जाता है, लेकिन प्रोडक्शन के लिए तैयार नहीं है। जेनरेटर सिर्फ उसी एक नमूने का वर्णन करता है जो आपने पेस्ट किया — संख्याएँ float64 बन जाती हैं, वैकल्पिक फ़ील्ड अपने आप कभी पॉइंटर नहीं बनते, omitempty खाली struct नहीं हटाता, और तारीखों की ज़्यादातर स्ट्रिंग string ही रह जाती हैं। पेस्ट करने के बाद ये चार खालियाँ आपका ही काम हैं।

API रिस्पॉन्स को Go struct में बदलना शुद्ध यांत्रिक काम है, और यांत्रिक काम की कीमत सन्नाटे में छिपी रहती है: गलत वर्तनी वाला फ़ील्ड नाम कंपाइल एरर नहीं देता, बस एक फ़ील्ड हमेशा के लिए शून्य रह जाता है; null के प्रबंधन में गलत स्विच — और "note": null उत्पादन में वहाँ आ जाता है जहाँ किसी ने उसकी आशा नहीं की। struct बनाना नामों और टाइप की समरेखन सुलझाता है, लेकिन दो चीज़ें कभी खुद समरेखित नहीं होतीं: आपके नमूने के बाहर के रूपभेद और Go के टाइप सिस्टम तथा JSON के बीच की खाई।

जेनरेटर असल में क्या पढ़ता है: मैपिंग टेबल

हर JSON → Go कन्वर्टर उसी टेबल पर चलता है। इस साइट के /convert/go पेज से एक सामान्य ऑर्डर रिस्पॉन्स गुज़ारें — नमूना पेस्ट करें, json टैग चालू करें — और यह रूप मिलेगा:

JSON मान बना हुआ Go टाइप टिप्पणियाँ
string string तारीख की स्ट्रिंग सामान्यतः string रहती है, नीचे time.Time देखें
पूर्णांक float64 encoding/json संख्याओं को अंदर double के रूप में पार्स करता है
दशमलव float64 मुद्रा फ़ील्ड को decimal लाइब्रेरी या छोटी इकाइयों में int64 करें
true / false bool कोई जाल नहीं
null any एक null नमूना कुछ सिद्ध नहीं करता, सतर्क fallback
ऑब्जेक्ट नाम वाला struct नेस्टेड ऑब्जेक्ट अपना struct बन जाते हैं
खाली ऑब्जेक्ट {} map[string]any कोई देखने योग्य फ़ील्ड नहीं, जेनरेटर अंदाज़ा नहीं लेता
ऐरे []एलिमेंटटाइप एलिमेंट का टाइप पहले नमूने से अनुमित
मिश्रित टाइप any Go में union नहीं है, कई टाइप वाले फ़ील्ड any में गिरते हैं
// इनपुट नमूना
// {"id":"A-1029","items":[{"sku":"J-01","qty":2}],"coupon":null}
type Root struct {
  ID     string `json:"id"`
  Items  []Item `json:"items"`
  Coupon any    `json:"coupon"`
}

type Item struct {
  Sku string `json:"sku"`
  Qty int    `json:"qty"`
}

तीन टिप्पणियाँ। नेस्टेड ऑब्जेक्ट items अपना struct Item बन गया, जिसे slice रेफरेंस करता है। coupon सिर्फ null के रूप में आया: जेनरेटर सिद्ध नहीं कर सकता कि बाद में यह क्या होगा, इसलिए any में गिरता है। संख्या qty टूल के अनुसार int या float64 बनकर उतरती है — रणनीतियाँ अलग हैं, पर सब उसी धारणा पर खड़ी हैं: नमूना पूरा सच है।

Json टैग: मूल नाम, विकल्प और आसान तीन गलतियाँ

टैग जेनरेटर के आउटपुट में सर्वाधिक सूचना-घनत्व ले जाते हैं और संपादन में गलती का सबसे आसान हिस्सा भी हैं। नियम सीधे encoding/json दस्तावेज़ से आते हैं:

Field int `json:"myName"`            // myName कुंजी के नीचे आता है
Field int `json:"myName,omitempty"`  // पूर्णांक फ़ील्ड खाली होने पर छूट जाता है
Field int `json:",omitempty"`        // डिफ़ॉल्ट फ़ील्ड नाम, सिर्फ विकल्प
Field int `json:"-"`                 // हमेशा अनदेखा, न एनकोड न डिकोड
Field int64 `json:"id,string"`       // संख्या स्ट्रिंग के अंदर एनकोड

याद रखने लायक तीन लापरवाहियाँ। पहली, json:",omitempty" में शुरुआती कॉमा — जब कुंजी का नाम बदले बिना सिर्फ खाली मान छोड़ने हों, कॉमा अनिवार्य है; उसके बिना फ़ील्ड को शब्दशः ,omitempty नाम की कुंजी माना जाता है। दूसरी, टैग में मूल JSON कुंजी रखें (user_id, html_url) जबकि Go फ़ील्ड प्रचलित ढंग अपनाए (UserID, HTMLURL): टैग के बिना मिलान फ़ील्ड के शब्दशः नाम पर होता है, इसलिए रिस्पॉन्स की userId कुंजी कभी मैप नहीं होती — चुपचाप। तीसरी, json:"-" के अतिरिक्त json:"-," भी है — बाद वाला मतलब कुंजी सचमुच - नाम की है।

पॉइंटर: nil ही "अनुपस्थित" को "शून्य" से अलग करने का एकमात्र तरीका

Go की शून्य-मान प्रणाली int और string को "फ़ील्ड मौजूद नहीं" कहने की इजाज़त नहीं देती — 0 और "" सच्चा डेटा भी हो सकते हैं, या बस पार्स नहीं हुए। एक ही JSON कुंजी की तीन अवस्थाएँ हैं: मान के साथ मौजूद, null के रूप में मौजूद, और अनुपस्थित। वैल्यू-टाइप सिर्फ पहली को ढकता है।

type Config struct {
  Note    string  `json:"note,omitempty"`   // केवल हूबहू "" होने पर छूटता है
  Alias   *string `json:"alias,omitempty"`  // nil होने पर छूटता है
  Details *Meta   `json:"details,omitempty"`
}

पॉइंटर फ़ील्ड का शून्य मान nil है। कुंजी न होने या null होने पर json.Unmarshal उसे nil छोड़ देता है, और omitempty ठीक उसी मामले में उसे छोड़ देता है। इसीलिए ज़्यादातर कन्वर्टर "नेस्टेड ऑब्जेक्ट के लिए पॉइंटर इस्तेमाल करें" स्विच देते हैं: चालू करें — नेस्टेड struct *Item बन जाते हैं, और PATCH रिक्वेस्ट में "फ़ील्ड नहीं भेजा गया" और "मिटाने के लिए null भेजा गया" अंततः अलग हो जाते हैं। कीमत है हर जगह nil-चेक — p.Address.Street Address के nil होने पर panic करता है, Go के JSON कोड की सबसे सामान्य रनटाइम क्रैश में से एक।

खाली struct जिसे omitempty हटा नहीं पाता, और वह गड्ढा जिसे omitzero भरता है

omitempty की आधिकारिक परिभाषा मान देखकर फैसला करती है: false, 0, nil पॉइंटर, nil इंटरफ़ेस और शून्य-लंबाई के ऐरे, slices, maps या स्ट्रिंग। ध्यान दें सूची में क्या नहीं है: खाली struct।

type Order struct {
  Meta Meta `json:"meta,omitempty"`
}
type Meta struct {
  Version string
  Build   int
}

// Meta{Version: "1.0"} → "meta":{"version":"1.0","build":0}
// Meta{}              → "meta":{}   ← omitempty ने कुछ नहीं किया

struct-टाइप फ़ील्ड omitempty द्वारा कभी नहीं छोड़ा जाता — वह मेमोरी में निश्चित आकार के पात्र के रूप में रहता है, और मौजूद पात्र "खाली" नहीं होता। समाधान फ़ील्ड को *Meta करना है; सिर्फ nil पॉइंटर फेंका जाता है। Go 1.24 से दूसरा स्विच है, omitzero: Go के शून्य मान से फैसला करता है, टाइप परिभाषित करे तो IsZero() bool बुलाता है — शून्य time.Time छोड़ने का एकमात्र रास्ता। encoding/json/v2 के साथ (Go 1.25 में प्रयोगात्मक) अर्थ फिर खिसकता है: v2 का omitempty एनकोड किए गए JSON परिणाम देखकर फैसला करता है (सिर्फ null, "", {}, [] खाली गिने जाते हैं), इसलिए count: 0 आउटपुट में रह जाता है; पुराने कोड के प्रवास में bool और सांख्यिक फ़ील्ड का omitempty omitzero बनना चाहिए, मूल अर्थ बनाए रखने के लिए।

हर संख्या float64 बनती है: बड़े पूर्णांकों का जाल

स्पष्ट टाइप के बिना encoding/json का डिकोडर संख्याओं को float64 मानता है, और float64 में मैंटिसा के सिर्फ 53 बिट हैं। JavaScript का क्लासिक मामला — 9007199254740993 बन जाना 9007199254740992 — Go में भी है, जब तक लक्ष्य-फ़ील्ड float64 या any है।

var v map[string]any
_ = json.Unmarshal([]byte(`{"id":9007199254740993}`), &v)
// v["id"] है float64(9007199254740992), परिशुद्धता तुरंत खो गई

तीन निकासी। struct का फ़ील्ड int64 घोषित करें, डिकोडर निर्भुल उसी में पार्स करेगा। any से जाना हो तो decoder.UseNumber() बुलाएँ ताकि संख्याएँ json.Number स्ट्रिंग बनकर उतरें, जिन्हें आप सजग रूप से बदलते हैं। पैसे पर कभी फ्लोटिंग-पॉइंट न चलाएँ — छोटी इकाइयाँ int64 में रखें या decimal लाइब्रेरी लें। API जब भी snowflake ID या 64 बिट ऑर्डर नंबर लौटाता है, यह हिस्सा अनिवार्य जाँच है।

time.Time केवल RFC 3339 स्वीकार करता है

"2024-01-15T10:30:00Z" के सामने जेनरेटर time.Time मैप करता है; "2024-01-15 10:30:00" के सामने string छोड़ देता है। आलस्य नहीं — encoding/json की कठोर बाधा है: time.Time UnmarshalJSON लागू करता है और सख़्ती से RFC 3339 लेआउट 2006-01-02T15:04:05Z07:00 में पार्स करता है। T न होना, टाइमज़ोन न होना या Z के बाद ऑफ़सेट — सब गिरते हैं:

parsing time "\"2022-07-27T14:16:00Z04:00\"" as
"\"2006-01-02T15:04:05Z07:00\"": cannot parse "04:00\"" as "\""

ऊपरी स्रोत का फॉर्मैट बदला न जा सके तो मानक समाधान है time.Time को लपेटने वाला कस्टम टाइप, जिसका UnmarshalJSON कई लेआउट आज़माता है:

type CustomDate struct{ time.Time }

func (c *CustomDate) UnmarshalJSON(b []byte) error {
  s := strings.Trim(string(b), `"`)
  t, err := time.Parse("2006-01-02 15:04:05", s)
  if err != nil {
    t, err = time.Parse(time.RFC3339, s)
    if err != nil {
      return fmt.Errorf("invalid date format: %w", err)
    }
  }
  c.Time = t
  return nil
}

बनने के बाद चार-चरण की चेकलिस्ट

चार चरण जेनरेटर के आउटपुट को प्रोडक्शन कोड से अलग करते हैं, और उनमें एक बार चलना बाद के डिबगिंग से सस्ता है:

  1. हर any fallback बदलें: any खोजें, हर fallback फ़ील्ड के लिए तीन से पाँच असली नमूने देखें, फिर ठोस टाइप या पॉइंटर पर उतारें;
  2. सांख्यिक चौड़ाई फिर जाँचें: ID, राशि और काउंटर float64 से int64 / int32 / decimal पर ले जाएँ; चौड़ाई पर संदेह हो तो int64 लिखें;
  3. वैकल्पिकता चिह्नित करें: ऐरे के ऑब्जेक्ट-फ़ील्ड, PATCH बॉडी और तीसरे पक्ष के API के nullable फ़ील्ड पर पॉइंटर या omitempty/omitzero — nil का अर्थ एक बार तय करें, यहीं;
  4. कंपाइल और आ-जा परीक्षण: go vet चलाएँ, फिर Marshal→Unmarshal आ-जा टेस्ट जोड़कर तार का फॉर्मैट बंद करें — आने वाले encoding/json अपडेट की आदत-खिसकन वह पकड़ लेगा।

नमूने से अनुबंध तक: कन्वर्टर की सीमा

कन्वर्टर उत्तर देता है "यह नमूना कैसा दिखता है", "यह इंटरफ़ेस हमेशा कैसा दिखेगा" नहीं। प्रतिद्वंद्वी टूल अपने ही दस्तावेज़ में यह साफ कहते हैं: एक नमूना प्रोडक्शन के रूपभेद सिद्ध नहीं कर सकता — वैकल्पिकता, तारीख के फॉर्मैट और enum मानों पर इंसान की समीक्षा चाहिए। तो आदत बनाइए: पेस्ट से पहले वही रिस्पॉन्स इकट्ठा करें जो अंतर सबसे आसानी से उगलते हैं (खाली सूची, सब फ़ील्ड, null से भरा एक); बनने के बाद आउटपुट को मसौदा समझें, प्रस्तुति नहीं। इंटरफ़ेस का अनुबंध-दस्तावेज़ हो तो JSON Schema से बाधाएँ स्पष्ट करें और बना कोड उससे समरेखित करें — नमूने से अनुमान को गुना हराता है। उसी समस्या के आड़े दृष्टिकोण में Java पक्ष हमारे Java जेनरेटर के मैदानी परीक्षण में है, फ्रंटएंड अनुबंध TypeScript इंटरफ़ेस में; सांख्यिक परिशुद्धता की खाई हर भाषा में अलग वेशभूषा में लौटती है, विस्तार JSON के बड़े संख्या जाल में।

बनने के बाद कौन-से फ़ील्ड अब भी हाथ से सुधार माँगते हैं?

कम से कम चार: any fallback, सांख्यिक चौड़ाई (float64 → int64), वैकल्पिक फ़ील्ड का पॉइंटर बनना, और तारीख के फ़ील्ड string हों या time.Time। चारों नमूने में अदृश्य प्रोडक्शन-रूपभेद हैं; जेनरेटर अंदाज़ा नहीं लेता, इंसान को पूरा करना है।

omitempty जोड़ने के बाद भी मेरा फ़ील्ड JSON में क्यों आता है?

omitempty सिर्फ शून्य मान छोड़ता है: false, 0, "", nil, खाली slices। खाली struct {} शून्य मान नहीं, इसलिए बच जाता है — फ़ील्ड पॉइंटर करें। शून्य time.Time को omitzero चाहिए, omitempty नहीं।

डिसीरियलाइज़ के बाद मेरा बड़ा पूर्णांक ID क्यों बदल गया?

स्पष्ट टाइप बिना encoding/json संख्याएँ float64 पार्स करता है, जिसकी मैंटिसा 53 बिट है; 2^53 के पार के पूर्णांक परिशुद्धता खोते हैं। फ़ील्ड int64 टाइप करें, या UseNumber() बुलाएँ ताकि संख्याएँ json.Number रहें।

नेस्टेड ऑब्जेक्ट-फ़ील्ड कब पॉइंटर होना चाहिए?

दो मामले: फ़ील्ड अनुपस्थित या null हो सकता है (nil "नहीं भेजा गया" को "शून्य मान" से अलग करता है), और PATCH रिक्वेस्ट को "नहीं भेजा गया" तथा "मिटाने के लिए null भेजा गया" में फर्क करना होता है। साधारण non-nullable फ़ील्ड वाले रिस्पॉन्स-struct में वैल्यू-टाइप सुरक्षित है — nil-चेक की कीमत सिर्फ तब चुकाएँ जब अलग करना सचमुच चाहिए।