JSON array और object कैसे लिखें: शुरुआती के लिए संरचना और nesting
मुख्य बात: JSON में सिर्फ दो कंटेनर हैं: नाम वाले फील्ड के लिए object, क्रमबद्ध सूची के लिए array। दोनों को जोड़ना, सही चुनना और तीन सबसे आम गलतियाँ ठीक करना सीखें — संख्यात्मक key वाले नकली array, अंत की अतिरिक्त comma और single quote।

JSON आपको सिर्फ दो कंटेनर देता है: object नाम वाले फील्ड बहन करता है, array क्रमबद्ध सूचियाँ — और लगभग हर टूटा payload उद्धरण चिह्नों, कॉमा, या नकली object जैसे लिखी गई सूची से समझाया जाता है।
एक: JSON में सिर्फ दो कंटेनर हैं
API का जवाब चाहे कितना भी जटिल हो, सब कुछ दो कंटेनरों और छह प्रकार के मानों में सिमट जाता है। object curly braces {} में बंद की-वैल्यू जोड़ियों का संग्रह है; array square brackets [] में बंद मानों की क्रमबद्ध सूची है। कोई वैल्यू string, number, true, false, null हो सकती है — या फिर object या array भी। array के अंदर object, object के अंदर array: यही recursion JSON की पूरी अभिव्यक्ति शक्ति है।
{
"user": { "name": "Ada", "active": true },
"roles": ["admin", "editor"],
"lastLogin": null,
"loginCount": 42
}
इससे एक व्यावहारिक निष्कर्ष निकलता है: उलझे payload के सामने उसे अक्षर-दर-अक्षर न पढ़ें। पहले देखें सबसे बाहरी अक्षर { है या [। object है तो उसे नाम वाले फील्ड की तरह पढ़ें; array है तो सूची की तरह पढ़ें और फिर एक-एक स्तर नीचे उतरें। json.org का सिंटैक्स आरेख ठीक एक पन्ने में आता है क्योंकि दो संरचनाएँ और recursion मिलकर सब कुछ कवर कर देते हैं।
दो: object लिखना, चार कठोर नियम
object वह जगह है जहाँ शुरुआती सबसे ज्यादा गलती करते हैं, लेकिन नियम चार में सिमटते हैं:
- Key डबल कोट्स में बंद string होनी चाहिए।
{name: "Ada"}और{'name': 'Ada'}दोनों अमान्य हैं; लिखना होगा{"name": "Ada"}। JavaScript के object literals नंगे key और single quote चलाते हैं, JSON नहीं — दोनों के बीच यही सबसे आम भ्रम है। - जोड़ियों को comma से अलग करें और आखिरी जोड़ी के बाद कभी comma न छोड़ें।
{"a": 1, "b": 2,}बंद brace परUnexpected token }के साथ असफल होता है। - Key अनोखी होनी चाहिए। RFC 8259 यह SHOULD कहता है, MUST नहीं: दोहराए गए key त्रुटि नहीं देते, पर पहली वैल्यू रहेगी या आखिरी वाली यह implementation पर निर्भर करता है, और भाषाएँ असहमत हैं। इस पर कभी भरोसा न करें।
- Key के क्रम का कोई अर्थ नहीं।
{"a":1,"b":2}और{"b":2,"a":1}एक ही object हैं; diff टूल और तुलना फंक्शन key का क्रम अनदेखा करते हैं। अगर क्रम महत्वपूर्ण है, डेटा array का होना चाहिए।
तीन: array लिखना, क्रम खुद डेटा है
array मान स्थिति के हिसाब से रखते हैं और इंडेक्सिंग 0 से शुरू होती है: ["admin", "editor"] में "editor" स्ट्रिंग [1] है। यह क्रम अर्थपूर्ण है — array और object का मूल अंतर यहीं है। relevance के अनुसार क्रमित खोज परिणाम, तारीख के अनुसार क्रमित log एंट्री: यह जानकारी केवल क्रम में रहती है, और object में बदलना उसे नष्ट कर देता है।
दो व्यावहारिक सिफारिशें। पहली, तत्वों को समरूप रखें: [{"id":1},{"id":2}] खाना कहीं आसान है [1, "text", true] के मुकाबले — वह वैध है पर हर उपभोक्ता को हर कदम पर type जाँचने को मजबूर करता है। दूसरी, खाली array [] पूरी तरह मान्य वैल्यू है — जब सूची फील्ड में अभी सामग्री नहीं है, null की जगह [] भेजें, ताकि उपभोक्ता को पहले अस्तित्व और फिर खालीपन जाँचना न पड़े।
[
{ "city": "Tokyo", "population": 13960000 },
{ "city": "Delhi", "population": 16780000 }
]
चार: nesting, असली payload के चार रूप
असली डेटा बस यही दो कंटेनर हैं जो एक-दूसरे में नेस्ट होते हैं, और पैटर्न चार रूपों में सिमटते हैं:
| रूप | दिखता कैसे है | सामान्य उपयोग |
|---|---|---|
| object में array | {"tags": ["a","b"]} |
किसी इकाई का सूची फील्ड |
| object का array | [{"id":1},{"id":2}] |
रिकॉर्ड सूचियाँ, पेजिनेटेड परिणाम |
| object में object | {"db": {"host": "..."}} |
समूहित कॉन्फिग, पता ब्लॉक |
| array का array | [[1,2],[3,4]] |
मैट्रिक्स, तालिका की पंक्तियाँ |
आम API जवाब object को आवरण और array को सामग्री के रूप में इस्तेमाल करता है:
{
"code": 0,
"data": {
"items": [
{ "id": 1, "title": "first" },
{ "id": 2, "title": "second" }
],
"page": 1,
"total": 2
}
}
सिर्फ nesting के लिए nest न करें। तीन-चार स्तरों के बाद पहुँच पथ अपठनीय हो जाते हैं और उपभोक्ता कोड उसी अनुपात में फूल जाता है। जो फील्ड हमेशा साथ चलते हैं वे sub-object के हकदार हैं: addrCity और addrZip को address: {city, zip} से बदल दें।
पाँच: object या array, एक निर्णय तालिका
| सवाल | जवाब | क्यों |
|---|---|---|
| हर वैल्यू का नाम है? | object | key से पहुँच; फील्ड जोड़ना या हटाना कुछ नहीं तोड़ता |
| मिलते-जुलते रिकॉर्ड की सूची है? | array | क्रम मायने रखता है; map और filter कर सकते हैं |
| key से तेज़ खोज चाहिए? | पहचानकर्ता से अनुक्रमित object | घूमने की जगह O(1) पहुँच |
| एक इकाई के कई गुण? | object | गुणों का अपना क्रम नहीं होता |
| मिलते-जुलते तत्वों का बढ़ता संग्रह? | array | लंबाई खुलकर बढ़ती है |
एक anti-pattern विशेष उल्लेख का हकदार है: "0", "1", "2" की key वाले object से array की नकल बनाना। वह बिना त्रुटि parse होता है, पर आप सच्चे array की लंबाई-अर्थव्यवस्था और iteration टूल खो देते हैं, और उपभोक्ताओं को कुछ पढ़ने से पहले Object.keys क्रमित करना पड़ता है। अगर key क्रमांक हैं, तो सच्चा array लिखें। उल्टा भी सही है: [{"key":"theme","value":"dark"}] जैसी की-वैल्यू जोड़ियों की सूची {"theme": "dark"} object से निकृष्ट है — जब तक कि key वाकई गतिशील न हों और पहले से घोषित न हो सकें।
छह: तीन आम गलतियाँ और उनके संदेश
| गलत रूप | आम त्रुटि | समाधान |
|---|---|---|
अंत की comma {"a":1,} |
Unexpected token } |
आखिरी comma हटाएँ |
Single quote / नंगे key {name:'Ada'} |
Unexpected token ' / Expected property name |
key और string पर हमेशा डबल कोट्स |
Python literals True / None |
Unexpected token T |
true / null से बदलें |
| संख्यात्मक key वाला नकली array | त्रुटि नहीं, अर्थ गलत | सच्चे array के रूप में फिर लिखें |
दो डिबगिंग आदतें: parser आमतौर पर दोषी अक्षर के बाद की स्थिति बताते हैं, इसलिए position 42 देखते ही एक-दो अक्षर पीछे देखें; और एक ही लाइन का विशाल JSON पहले format करें — लाइन और कॉलम नंबर हर बार कैरेक्टर ऑफसेट को हरा देते हैं। त्रुटियों का पूरा कैटलॉग JSON त्रुटि लुकअप तालिका में है, और कदम-दर-कदम ट्रायाज प्रक्रिया JSON parse error कैसे ठीक करें में।
सात: लिखने के बाद संरचना सत्यापित करें
हाथ से लिखा JSON सौंपने से पहले हमेशा parser से गुजरना चाहिए। सबसे हल्की जाँच एक कमांड लाइन में सिमटती है:
python3 -m json.tool config.json > /dev/null && echo OK
jq empty config.json && echo OK
ऑनलाइन, JSON formatter और validator पेज पर सामग्री चिपकाएँ — सिंटैक्स त्रुटियाँ लाइन और कॉलम सहित लौटेंगी। ट्री व्यू पर जाएँ ताकि हर स्तर का type एक नजर में दिखे: कोई संख्या string पढ़ी गई या नहीं, array की लंबाइयाँ मेल खाती हैं या नहीं। और जब पाठक तकनीकी नहीं हैं, array-of-objects payload को JSON से तालिका पेज पर पंक्तियों और कॉलमों में बिछाया जा सकता है — साथ ही यह भी जाँच बन जाती है कि आपका डेटा वाकई नियमित रिकॉर्ड सूची है या नहीं।
उस फील्ड के सवाल जो array होना चाहिए था, या बहुत गहरे nesting की पुनर्रचना, type मॉडलिंग का विषय हैं — अगला पाठ: छह types, संख्यात्मक सटीकता और encoding जाल।
JSON array और object आपस में बदले जा सकते हैं?
हाँ, पर बिना हानि नहीं। object को array बनाना आमतौर पर key को वैल्यू बनाना और key से पहुँच खोना है; array को object बनाने के लिए हर तत्व के लिए key बनानी पड़ती है, और उन key का उद्गम नया डिज़ाइन सवाल बन जाता है। सिंटैक्स की सुविधा से नहीं, उपभोक्ता के डेटा पढ़ने के तरीके से फैसला करें।
object की key दोहराई जा सकती है?
सिंटैक्स के हिसाब से हाँ — RFC 8259 केवल कहता है key SHOULD अनोखी हों। लेकिन JavaScript आखिरी वैल्यू रखता है जबकि कुछ C-परिवार की लाइब्रेरी पहली रखती हैं: parser के हिसाब से व्यवहार अलग है। सिग्नेचर, diff या hash में दोहराए key सीधी विसंगतियाँ देते हैं। निर्माता पक्ष पर इनसे बचें, और अनजान स्रोत के डुप्लिकेट को उपभोक्ता पक्ष का जोखिम मानें।
array विभिन्न types की वैल्यू रख सकता है?
सिंटैक्स के हिसाब से हाँ: [1, "a", true] मान्य JSON है। पर असमरूप array उपभोक्ता को हर स्थिति पर type जाँचने को मजबूर करते हैं और schema में व्यक्त करना कठिन है। मैट्रिक्स और टुपल छोड़कर — जहाँ स्थिति ही अर्थ है — array को समरूप रखें।
{name:'json'} वैलिडेशन में क्यों असफल होता है?
क्योंकि JSON हर key और हर string वैल्यू के चारों ओर डबल कोट्स माँगता है। {name:'json'} JavaScript का object literal है, JSON नहीं। इसे {"name": "json"} से बदलें, वैलिडेशन पास हो जाएगा। Single quote, नंगे key और कमेंट JSON5/JSONC जैसे बोलियों की चीज़ हैं, जिनके लिए मानक JSON.parse की जगह अपने parser चाहिए।