जावास्क्रिप्ट में JSON के साथ काम करना: शुरुआती लोगों के लिए पार्सिंग और सीरियलाइज़ेशन

परिचय: JSON क्या है और जावास्क्रिप्ट में इसकी आवश्यकता क्यों है?

JSON (JavaScript Object Notation) एक हल्का टेक्स्ट-आधारित डेटा विनिमय प्रारूप है, जो जावास्क्रिप्ट ऑब्जेक्ट्स के सिंटैक्स पर आधारित है। अपने नाम के बावजूद, JSON भाषा-स्वतंत्र है और लगभग सभी आधुनिक प्रोग्रामिंग भाषाओं द्वारा समर्थित है। Node.js और ब्राउज़र जावास्क्रिप्ट के इकोसिस्टम में, JSON के साथ काम करना सबसे सामान्य ऑपरेशनों में से एक है: API से डेटा प्राप्त करने से लेकर कॉन्फ़िगरेशन सहेजने और सर्वर और क्लाइंट के बीच जानकारी स्थानांतरित करने तक।

इस लेख में, हम दो मुख्य विधियों को समझेंगे: JSON.parse() (JSON स्ट्रिंग को जावास्क्रिप्ट ऑब्जेक्ट में बदलना) और JSON.stringify() (जावास्क्रिप्ट ऑब्जेक्ट को JSON स्ट्रिंग में बदलना)। आप त्रुटियों को सही ढंग से संभालना, नेस्टेड संरचनाओं के साथ काम करना और इन विधियों की उन्नत क्षमताओं का उपयोग करना सीखेंगे।

1. JSON पार्सिंग: JSON.parse() विधि

JSON.parse() विधि JSON प्रारूप में एक स्ट्रिंग लेती है और इसे जावास्क्रिप्ट ऑब्जेक्ट, ऐरे या प्रिमिटिव वैल्यू में बदल देती है। यह मुख्य ऑपरेशन है जब आप किसी बाहरी स्रोत से डेटा प्राप्त करते हैं - उदाहरण के लिए, REST API या फ़ाइल से।

मूल सिंटैक्स

const jsonString = '{"name": "अन्ना", "age": 30, "isStudent": false}';const user = JSON.parse(jsonString);

console.log(user.name);      // "अन्ना"console.log(user.age);       // 30console.log(user.isStudent); // false

ध्यान दें: JSON में कुंजियाँ और स्ट्रिंग मान अनिवार्य रूप से डबल कोट्स में होने चाहिए। सिंगल कोट्स या कुंजियों के बिना कोट्स त्रुटि का कारण बनेंगे।

ऐरे को पार्स करना

JSON में न केवल ऑब्जेक्ट बल्कि ऐरे भी हो सकते हैं:

const jsonArray = '[1, 2, 3, "चार", true]';const arr = JSON.parse(jsonArray);

console.log(arr[0]); // 1console.log(arr[3]); // "चार"

नेस्टेड संरचनाएँ

JSON असीमित नेस्टिंग का समर्थन करता है:

const complexJson = '{"users":[{"id":1,"name":"इवान"},{"id":2,"name":"मारिया"}]}';const data = JSON.parse(complexJson);

console.log(data.users[0].name); // "इवान"console.log(data.users[1].id);   // 2

पार्सिंग त्रुटियों को संभालना

यदि स्ट्रिंग में अमान्य JSON है, तो JSON.parse() एक SyntaxError अपवाद फेंकेगा। बाहरी डेटा के साथ काम करते समय हमेशा try/catch का उपयोग करें:

const invalidJson = '{"name": "पीटर", age: 25}'; // त्रुटि: age बिना कोट्स के

try {    const obj = JSON.parse(invalidJson);    console.log(obj);} catch (error) {    console.error('JSON पार्सिंग त्रुटि:', error.message);    // आउटपुट: JSON पार्सिंग त्रुटि: Unexpected token 'a', ...}

उन्नत उपयोग: reviver फ़ंक्शन

JSON.parse() का दूसरा पैरामीटर एक reviver फ़ंक्शन है, जो पार्सिंग के दौरान मानों को बदलने की अनुमति देता है। उदाहरण के लिए, आप तिथियों वाली स्ट्रिंग्स को स्वचालित रूप से Date ऑब्जेक्ट्स में बदल सकते हैं:

const jsonWithDate = '{"name": "ईवेंट", "date": "2025-03-15T10:00:00.000Z"}';

const event = JSON.parse(jsonWithDate, (key, value) => {    if (key === 'date') {        return new Date(value);    }    return value;});

console.log(event.date instanceof Date); // trueconsole.log(event.date.getFullYear());   // 2025

2. JSON सीरियलाइज़ेशन: JSON.stringify() विधि

JSON.stringify() विधि विपरीत ऑपरेशन करती है - यह जावास्क्रिप्ट ऑब्जेक्ट या मान को JSON स्ट्रिंग में बदल देती है। सर्वर पर डेटा भेजने, फ़ाइल में सहेजने या लॉगिंग के लिए यह आवश्यक है।

मूल सिंटैक्स

const user = {    name: "ओल्गा",    age: 28,    isAdmin: true,    skills: ["JS", "Python", "SQL"]};

const jsonString = JSON.stringify(user);console.log(jsonString);// {"name":"ओल्गा","age":28,"isAdmin":true,"skills":["JS","Python","SQL"]}

सुंदर प्रिंटिंग (इंडेंटेशन)

पठनीयता के लिए, JSON.stringify() तीसरा पैरामीटर ले सकता है - इंडेंटेशन के लिए स्पेस की संख्या:

const prettyJson = JSON.stringify(user, null, 2);console.log(prettyJson);// {//   "name": "ओल्गा",//   "age": 28,//   "isAdmin": true,//   "skills": [//     "JS",//     "Python",//     "SQL"//   ]// }

replacer पैरामीटर

दूसरा पैरामीटर (replacer) एक फ़ंक्शन या ऐरे हो सकता है जो यह नियंत्रित करता है कि JSON स्ट्रिंग में कौन से गुण शामिल किए जाएँ:

const user = {    name: "दिमित्री",    age: 35,    password: "secret123",    email: "dmitry@example.com"};

// केवल निर्दिष्ट कुंजियाँ शामिल करेंconst safeJson = JSON.stringify(user, ['name', 'email']);console.log(safeJson);// {"name":"दिमित्री","email":"dmitry@example.com"}

// या फ़ंक्शन का उपयोग करेंconst filteredJson = JSON.stringify(user, (key, value) => {    if (key === 'password') {        return undefined; // पासवर्ड को बाहर करें    }    return value;});console.log(filteredJson);// {"name":"दिमित्री","age":35,"email":"dmitry@example.com"}

महत्वपूर्ण सीमाएँ

सभी मानों को JSON में सीरियलाइज़ नहीं किया जा सकता:

const specialValues = {    func: function() { return "हैलो"; },    undef: undefined,    symbol: Symbol('id'),    inf: Infinity,    nan: NaN};

console.log(JSON.stringify(specialValues));// {"inf":null,"nan":null} // फ़ंक्शन, undefined और Symbol छोड़ दिए गए

यदि किसी ऑब्जेक्ट में toJSON() विधि है, तो JSON.stringify() मानक व्यवहार के बजाय इस विधि के परिणाम का उपयोग करेगा:

const date = new Date();console.log(JSON.stringify(date));// "2025-03-15T10:00:00.000Z" - Date में अंतर्निहित toJSON() है

3. व्यावहारिक उदाहरण: API के साथ काम करना

आइए एक वास्तविक परिदृश्य देखें: Node.js में REST API से डेटा प्राप्त करना और भेजना।

API से डेटा प्राप्त करना (GET-अनुरोध)

const fetch = require('node-fetch'); // Node.js के लिए

async function getUserData(userId) {    try {        const response = await fetch(`https://api.example.com/users/${userId}`);                if (!response.ok) {            throw new Error(`HTTP त्रुटि! स्थिति: ${response.status}`);        }                const jsonString = await response.text();        const userData = JSON.parse(jsonString);                console.log('उपयोगकर्ता डेटा:', userData);        return userData;    } catch (error) {        console.error('डेटा प्राप्त करने में त्रुटि:', error.message);        throw error;    }}

getUserData(123);

सर्वर पर डेटा भेजना (POST-अनुरोध)

async function createUser(userData) {    try {        const jsonBody = JSON.stringify(userData);                const response = await fetch('https://api.example.com/users', {            method: 'POST',            headers: {                'Content-Type': 'application/json'            },            body: jsonBody        });                const result = await response.json();        console.log('उपयोगकर्ता बनाया गया:', result);        return result;    } catch (error) {        console.error('डेटा भेजने में त्रुटि:', error.message);        throw error;    }}

const newUser = {    name: "एकातेरिना",    email: "ekaterina@example.com",    age: 32};

createUser(newUser);

4. सामान्य गलतियाँ और सर्वोत्तम प्रथाएँ

गलती #1: सिंगल कोट्स या बिना कोट्स के कुंजियाँ

// गलत:const badJson = "{'name': 'एलेक्स'}";JSON.parse(badJson); // SyntaxError

// सही:const goodJson = '{"name": "एलेक्स"}';JSON.parse(goodJson); // ठीक है

गलती #2: अंतिम आइटम के बाद अल्पविराम

// गलत:const badJson = '{"name": "एलेक्स", "age": 30,}';JSON.parse(badJson); // SyntaxError

// सही:const goodJson = '{"name": "एलेक्स", "age": 30}';JSON.parse(goodJson); // ठीक है

गलती #3: JSON.parse() को try/catch के बिना कॉल करना

// जोखिम भरा:const data = JSON.parse(someExternalString);

// सुरक्षित:try {    const data = JSON.parse(someExternalString);} catch (e) {    console.error('अमान्य JSON:', e.message);}

गलती #4: सर्कुलर संदर्भों को सीरियलाइज़ करने का प्रयास

const objA = { name: "A" };const objB = { name: "B" };objA.ref = objB;objB.ref = objA; // सर्कुलर संदर्भ

// TypeError: Converting circular structure to JSON// console.log(JSON.stringify(objA));

// समाधान: सर्कुलर संदर्भों को हटाने के लिए replacer का उपयोग करेंconst seen = new WeakSet();const safeJson = JSON.stringify(objA, (key, value) => {    if (typeof value === 'object' && value !== null) {        if (seen.has(value)) {            return '[सर्कुलर]';        }        seen.add(value);    }    return value;});console.log(safeJson);// {"name":"A","ref":{"name":"B","ref":"[सर्कुलर]"}}

निष्कर्ष

JSON के साथ काम करना किसी भी जावास्क्रिप्ट डेवलपर के लिए एक मूलभूत कौशल है। JSON.parse() और JSON.stringify() विधियाँ सरल लेकिन शक्तिशाली उपकरण हैं जो आपको डेटा को सीरियलाइज़ और डी-सीरियलाइज़ करने की अनुमति देती हैं। याद रखने योग्य मुख्य बातें:

• हमेशा JSON.parse() को try/catch ब्लॉक में लपेटें
• JSON स्ट्रिंग्स में केवल डबल कोट्स का उपयोग करें
• सीरियलाइज़ेशन को नियंत्रित करने के लिए replacer और इंडेंटेशन का उपयोग करें
• सर्कुलर संदर्भों और गैर-सीरियलाइज़ करने योग्य मानों (फ़ंक्शन, undefined, Symbol) से सावधान रहें
• डेटा विनिमय के लिए JSON प्रारूप का उपयोग करें, लेकिन जटिल ऑब्जेक्ट्स को संग्रहीत करने के लिए नहीं

अब आप जावास्क्रिप्ट में JSON के साथ आत्मविश्वास से काम करने के लिए तैयार हैं! अपने प्रोजेक्ट्स में अभ्यास करें और जल्द ही ये विधियाँ आपकी दूसरी प्रकृति बन जाएँगी।