JSON से कोड जनरेटर

JSON to code जनरेटर क्या है?#

एक JSON to code जनरेटर एक नमूना JSON दस्तावेज़ पढ़ता है, डेटा का आकार समझता है — कौन से फ़ील्ड स्ट्रिंग हैं, कौन से नंबर, कौन से नेस्टेड ऑब्जेक्ट, कौन से किसके ऐरे हैं — और एंटिटी टाइप्स लिखता है जिन्हें कोई वास्तविक प्रोग्राम उस डेटा को पकड़ने में उपयोग करेगा। किसी API रिस्पॉन्स से मिलान करने के लिए हाथ से TypeScript इंटरफ़ेस, Java क्लास, Go स्ट्रक्ट, या C# क्लास कोड करने के बजाय, आप एक उदाहरण रिस्पॉन्स चिपकाते हैं और अपनी परियोजना में डालने के लिए तैयार टाइप्स पाते हैं।

पर्दे के पीछे यह पार्स किए गए वैल्यू पर चलता है और एक स्कीमा अनुमानित करता है। नेस्टेड ऑब्जेक्ट्स अपना नामित टाइप बन जाते हैं; एक ऐरे का एलिमेंट टाइप हर एलिमेंट के आकार का मर्ज होता है (तो ऐसे ऑब्जेक्ट्स की सूची जिनकी सभी कुंजीयाँ समान नहीं हैं, फिर भी क्षेत्रों के यूनियन के साथ एक टाइप देती है)। फ़ील्ड नाम जो मान्य आइडेंटिफ़ायर नहीं हैं — जैसे हाइफ़न वाली कुंजी first-name, या अंक से शुरू होने वाली — को एक क़ानूनी आइडेंटिफ़ायर में बदला जाता है और मूल कुंजी को एक सीरियलाइज़ेशन एनोटेशन के रूप में सुरक्षित रखा जाता है, ताकि राउंड-ट्रिप अभी भी काम करे।

आउटपुट प्लेन-टेक्स्ट सोर्स कोड है जिसकी इस पेज पर कोई रनटाइम निर्भरता नहीं। इसे कॉपी करें, अपने कोडबेस में चिपकाएँ, टाइप नाम समायोजित करें, और आपके पास एक शुरुआती बिंदु है — कोई पूर्ण मॉडल नहीं, पर ऊब भरा ढाँचा पहले से आपके लिए लिखा हुआ।

इसका उपयोग कैसे करें#

1. भाषा ड्रॉपडाउन से लक्ष्य चुनें: TypeScript, Java, Go, या C#।
2. रूट नाम सेट करें (डिफ़ॉल्ट Root)। यह सबसे बाहरी टाइप का नाम बन जाता है — जैसे User, Order, Response।
3. अपना JSON बाईं पैनल में चिपकाएँ। जनरेट किया गया कोड दाईं ओर लाइव दिखाई देता है; स्थिति पट्टी त्रुटियाँ बताती है (अमान्य JSON, खाली इनपुट)।
4. कोड को क्लिपबोर्ड पर लेने के लिए कॉपी पर क्लिक करें।
5. नमूना एक सब-ऑब्जेक्ट और एक ऐरे वाला नेस्टेड ऑब्जेक्ट लोड करता है; साफ़ करें दोनों पैनलों को रीसेट करता है।

प्रमुख विशेषताएँ#

• चार लक्ष्य भाषाएँ। TypeScript इंटरफ़ेस, Java क्लास, Go स्ट्रक्ट, और C# क्लास — एक इनपुट, चार आउटपुट, एक ड्रॉपडाउन से बदले जाते हैं।
• स्कीमा अनुमान, न कि शाब्दिक टाइपिंग। नेस्टेड ऑब्जेक्ट्स नामित टाइप बन जाते हैं; ऑब्जेक्ट्स के ऐरे एक अपारदर्शी any सूची के बजाय एक नामित एलिमेंट टाइप देते हैं।
• विषम-ऐरे मर्जिंग। जब ऐरे एलिमेंट्स के अलग-अलग फ़ील्ड होते हैं, तो अनुमानित टाइप यूनियन होता है — गन्दे वास्तविक-दुनिया रिस्पॉन्स के लिए उपयोगी जहाँ हर आइटम में हर कुंजी नहीं होती।
• आइडेंटिफ़ायर-सुरक्षित, कुंजी-विश्वसनीय। जो कुंजीयाँ मान्य आइडेंटिफ़ायर नहीं हैं उन्हें साफ़ किया जाता है, और मूल कुंजी एक सीरियलाइज़ेशन एनोटेशन (@JsonProperty, एक Go json: टैग, JsonPropertyName) के रूप में रखी जाती है, ताकि मूल JSON अभी भी सही ढंग से डिसीरियलाइज़ हो।
• लाइव और स्थानीय। जनरेशन आपके ब्राउज़र में टाइप करते या विकल्प बदलते ही चलता है; डेटा कभी पेज से बाहर नहीं जाता।

कार्य उदाहरण#

भाषा TypeScript पर सेट और रूट नाम Root के साथ नमूना लोड करें, और इनपुट है:

{
  "id": 1,
  "name": "Ada",
  "active": true,
  "address": { "city": "London", "zip": "NW1" },
  "tags": ["math", "logic"]
}

जनरेटर दो इंटरफ़ेस निकालता है — रूट, और नेस्टेड ऑब्जेक्ट के लिए एक नामित Address टाइप:

export interface Root {
  id: number;
  name: string;
  active: boolean;
  address: Address;
  tags: Array<string>;
}

export interface Address {
  city: string;
  zip: string;
}

भाषा को Go पर स्विच करें और वही इनपुट मूल कुंजीयाँ सुरक्षित रखते json: टैग वाले स्ट्रक्ट बन जाता है:

package model

type Root struct {
  Id       float64   `json:"id"`
  Name     string    `json:"name"`
  Active   bool      `json:"active"`
  Address  Address   `json:"address"`
  Tags     []string  `json:"tags"`
}

type Address struct {
  City  string  `json:"city"`
  Zip   string  `json:"zip"`
}

ध्यान दें कि कैसे id, एक JSON नंबर, TypeScript में number और Go में float64 जाता है — जनरेटर पूर्णांक बनाम फ़्लोटिंग-पॉइंट का अनुमान नहीं लगाता, क्योंकि JSON खुद उनमें भेद नहीं करता।

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

मेरा पूर्णांक फ़ील्ड float64 / Double / double क्यों टाइप होता है?#

क्योंकि JSON में एकल नंबर टाइप है और 5 को 5.0 से अलग करने का कोई तरीका नहीं। जनरेटर हर JSON नंबर को लक्ष्य भाषा के सामान्य न्यूमेरिक टाइप से मैप करता है — TypeScript में number, Java में Double, Go में float64, C# में double — ताकि टाइप हमेशा इतना विस्तृत हो कि जो वैल्यू निकले उसे सक्षमता से पकड़ ले। यदि आप जानते हैं कि कोई फ़ील्ड हमेशा पूर्णांक है, तो बाद में हाथ से उसे int / Long / int64 पर सिकोड़ें।

जब मेरे ऐरे के ऑब्जेक्ट्स में सभी के फ़ील्ड एक जैसे नहीं होते तो क्या होता है?#

उनके आकार मर्ज हो जाते हैं। [{ "a": 1 }, { "a": 2, "b": "x" }] जैसा ऐरे दोनों a और b वाला एक एलिमेंट टाइप देता है, ताकि एक ही टाइप हर आइटम को कवर करे। यदि दो एलिमेंट्स किसी फ़ील्ड के टाइप पर असंगत तरीके से असहमत हों (जैसे यहाँ नंबर, वहाँ स्ट्रिंग), तो वह फ़ील्ड एक पक्ष चुनने और दूसरे के बारे में गलत होने के बजाय any / Object में गिर जाता है।

मेरे JSON के एक फ़ील्ड में हाइफ़न है, जैसे first-name। क्या वह टूट जाएगा?#

नहीं। जनरेटर first-name को फ़ील्ड नाम के लिए एक क़ानूनी आइडेंटिफ़ायर (firstName) बनाता है और एक सीरियलाइज़ेशन एनोटेशन निकालता है जो मूल कुंजी दर्ज करता है — Java में @JsonProperty("first-name"), Go में एक json:"first-name" टैग, C# में [JsonPropertyName("first-name")], और TypeScript में एक कोटेड "first-name" कुंजी। जनरेट किया गया कोड इसलिए मूल JSON को अपरिवर्तित डिसीरियलाइज़ करता है।

यह किसी null वैल्यू के साथ क्या करता है?#

जिस फ़ील्ड का वैल्यू null है उसे अज्ञात टाइप माना जाता है। TypeScript में यह एक वैकल्पिक any (field?: any;) बन जाता है; Java और C# में यह Object / object बनता है; Go में, interface{}। यह एक जानबूझकर संकेत है — null आपको इस बारे में कुछ नहीं बताता कि फ़ील्ड मौजूद होने पर क्या रखता है, इसलिए जनरेटर अनुमान लगाने से इनकार करता है और उसे आपके भरने के लिए छोड़ देता है।