JavaScript
JSON

परिचय

वाक्य - विन्यास

• JSON.parse (इनपुट [, reviver])
• JSON.stringify (मान [, प्रतिकृति [, स्थान]])

पैरामीटर

टिप्पणियों

एक साधारण JSON स्ट्रिंग पार्स करना

JSON.parse() विधि JSON के रूप में एक स्ट्रिंग को पार्स करती है और एक जावास्क्रिप्ट आदिम, सरणी या ऑब्जेक्ट देता है:

const array = JSON.parse('[1, 2, "c", "d", {"e": false}]');
console.log(array); // logs: [1, 2, "c", "d", {e: false}]

किसी मूल्य को क्रमबद्ध करना

जावास्क्रिप्ट मूल्य JSON.stringify फ़ंक्शन का उपयोग करके JSON स्ट्रिंग में परिवर्तित किया जा सकता है।

JSON.stringify(value[, replacer[, space]])

1. value JSON स्ट्रिंग में कनवर्ट करने के लिए मान।

/* Boolean */  JSON.stringify(true)             // 'true'
/* Number  */  JSON.stringify(12)               // '12'
/* String  */  JSON.stringify('foo')            // '"foo"'
/* Object  */  JSON.stringify({})               // '{}'
               JSON.stringify({foo: 'baz'})     // '{"foo": "baz"}'
/* Array   */  JSON.stringify([1, true, 'foo']) // '[1, true, "foo"]'
/* Date    */  JSON.stringify(new Date())       // '"2016-08-06T17:25:23.588Z"'
/* Symbol  */  JSON.stringify({x:Symbol()})     // '{}'

2. replacer एक फ़ंक्शन जो स्ट्रिंग प्रक्रिया और एक स्ट्रिंग स्ट्रिंग और संख्या ऑब्जेक्ट के व्यवहार को बदल देता है जो JSON स्ट्रिंग में शामिल किए जाने वाले मान ऑब्जेक्ट के गुणों को फ़िल्टर करने के लिए एक श्वेतसूची के रूप में काम करता है। यदि यह मान शून्य है या प्रदान नहीं किया गया है, तो ऑब्जेक्ट के सभी गुण परिणामी JSON स्ट्रिंग में शामिल हैं।

// replacer as a function
function replacer (key, value) {
    // Filtering out properties
    if (typeof value === "string") {
        return
    }    
    return value
}

var foo = { foundation: "Mozilla", model: "box", week: 45, transport: "car", month: 7 }
JSON.stringify(foo, replacer)
// -> '{"week": 45, "month": 7}'

// replacer as an array
JSON.stringify(foo, ['foundation', 'week', 'month'])
// -> '{"foundation": "Mozilla", "week": 45, "month": 7}'
// only the `foundation`, `week`, and `month` properties are kept

3. space पठनीयता के लिए, इंडेंटेशन के लिए उपयोग किए जाने वाले रिक्त स्थान की संख्या तीसरे पैरामीटर के रूप में निर्दिष्ट की जा सकती है।

JSON.stringify({x: 1, y: 1}, null, 2)  // 2 space characters will be used for indentation
/* output:
    {
      'x': 1,
      'y': 1
    }
*/

वैकल्पिक रूप से, इंडेंटेशन के लिए उपयोग करने के लिए एक स्ट्रिंग मान प्रदान किया जा सकता है। उदाहरण के लिए, '\t' करने से टैब वर्ण इंडेंटेशन के लिए उपयोग किया जाएगा।

JSON.stringify({x: 1, y: 1}, null, '\t')
/* output:
    {
        'x': 1,
        'y': 1
    }
*/

एक प्रतिकृति समारोह के साथ सीरियल

एक replacer फ़ंक्शन का उपयोग क्रमबद्ध होने वाले मानों को फ़िल्टर करने या बदलने के लिए किया जा सकता है।

const userRecords = [
  {name: "Joe", points: 14.9, level: 31.5},
  {name: "Jane", points: 35.5, level: 74.4},
  {name: "Jacob", points: 18.5, level: 41.2},
  {name: "Jessie", points: 15.1, level: 28.1},
];

// Remove names and round numbers to integers to anonymize records before sharing
const anonymousReport = JSON.stringify(userRecords, (key, value) =>
  key === 'name'
    ? undefined
    : (typeof value === 'number' ? Math.floor(value) : value)
);

यह निम्नलिखित स्ट्रिंग पैदा करता है:

'[{"points":14,"level":31},{"points":35,"level":74},{"points":18,"level":41},{"points":15,"level":28}]'

एक रिवीवर फ़ंक्शन के साथ पार्सिंग

एक रिवीवर फ़ंक्शन का उपयोग पार्स किए जा रहे मान को फ़िल्टर करने या बदलने के लिए किया जा सकता है।

var jsonString = '[{"name":"John","score":51},{"name":"Jack","score":17}]';

var data = JSON.parse(jsonString, function reviver(key, value) {
  return key === 'name' ? value.toUpperCase() : value;
});

const jsonString = '[{"name":"John","score":51},{"name":"Jack","score":17}]';

const data = JSON.parse(jsonString, (key, value) =>
  key === 'name' ? value.toUpperCase() : value
);

यह निम्न परिणाम उत्पन्न करता है:

[
  {
    'name': 'JOHN',
    'score': 51
  },
  {
    'name': 'JACK',
    'score': 17
  }
]

यह विशेष रूप से उपयोगी है जब डेटा को भेजा जाना चाहिए जिसे JSON के साथ प्रसारित होने पर क्रमबद्ध / एन्कोड किया जाना चाहिए, लेकिन कोई इसे deserialized / decoded एक्सेस करना चाहता है। निम्नलिखित उदाहरण में, एक तारीख को इसके आईएसओ 8601 प्रतिनिधित्व के लिए एन्कोड किया गया था। हम जावास्क्रिप्ट Date में इसे पार्स करने के लिए रिवाइवर फ़ंक्शन का उपयोग करते हैं।

var jsonString = '{"date":"2016-01-04T23:00:00.000Z"}';

var data = JSON.parse(jsonString, function (key, value) {
  return (key === 'date') ? new Date(value) : value;
});

const jsonString = '{"date":"2016-01-04T23:00:00.000Z"}';

const data = JSON.parse(jsonString, (key, value) =>
  key === 'date' ? new Date(value) : value
);

यह सुनिश्चित करना महत्वपूर्ण है कि प्रत्येक पुनरावृत्ति के अंत में reviver फ़ंक्शन उपयोगी मान लौटाता है। यदि रिवीवर फ़ंक्शन undefined , तो कोई मूल्य या निष्पादन फ़ंक्शन के अंत की ओर नहीं आता है, तो संपत्ति ऑब्जेक्ट से हटा दी जाती है। अन्यथा, संपत्ति को फिर से परिभाषित मूल्य होने के लिए पुनर्परिभाषित किया जाता है।

वर्ग उदाहरणों को क्रमबद्ध करना और पुनर्स्थापित करना

आप JSON में अपने स्वयं के वर्ग के उदाहरणों को प्रसारित करने के लिए एक कस्टम toJSON विधि और toJSON फ़ंक्शन का उपयोग कर सकते हैं। यदि किसी वस्तु में एक toJSON विधि है, तो उसका परिणाम वस्तु के बजाय क्रमबद्ध होगा।

function Car(color, speed) {
  this.color = color;
  this.speed = speed;
}

Car.prototype.toJSON = function() {
  return {
    $type: 'com.example.Car',
    color: this.color,
    speed: this.speed
  };
};

Car.fromJSON = function(data) {
  return new Car(data.color, data.speed);
};

class Car {
  constructor(color, speed) {
    this.color = color;
    this.speed = speed;
    this.id_ = Math.random();
  }

  toJSON() {
    return {
      $type: 'com.example.Car',
      color: this.color,
      speed: this.speed
    };
  }

  static fromJSON(data) {
    return new Car(data.color, data.speed);
  }
}

var userJson = JSON.stringify({
  name: "John",
  car: new Car('red', 'fast')
});

यह निम्नलिखित सामग्री के साथ एक स्ट्रिंग पैदा करता है:

{"name":"John","car":{"$type":"com.example.Car","color":"red","speed":"fast"}}

var userObject = JSON.parse(userJson, function reviver(key, value) {
  return (value && value.$type === 'com.example.Car') ? Car.fromJSON(value) : value;
});

यह निम्नलिखित वस्तु का उत्पादन करता है:

{
  name: "John",
  car: Car {
    color: "red",
    speed: "fast",
    id_: 0.19349242527065402
  }
}

JSON बनाम जावास्क्रिप्ट शाब्दिक

JSON का अर्थ "जावास्क्रिप्ट ऑब्जेक्ट नोटेशन" है, लेकिन यह जावास्क्रिप्ट नहीं है। इसे केवल एक डेटा क्रमांकन प्रारूप के रूप में सोचें जो कि जावास्क्रिप्ट शाब्दिक के रूप में सीधे प्रयोग करने योग्य होता है। हालाँकि, यह सीधे तौर पर चलाने (यानी eval() माध्यम से) JSON के लिए उचित नहीं है जो किसी बाहरी स्रोत से लाया जाता है। कार्यात्मक रूप से, JSON XML या YAML से बहुत अलग नहीं है - कुछ भ्रम से बचा जा सकता है यदि JSON को केवल कुछ क्रमांकन प्रारूप के रूप में कल्पना की जाती है जो जावास्क्रिप्ट की तरह बहुत अधिक दिखता है।

भले ही नाम का अर्थ सिर्फ वस्तुओं से है, और यहां तक कि अधिकांश प्रकार के एपीआई के माध्यम से उपयोग के मामले हमेशा ऑब्जेक्ट और सरणियों के होते हैं, JSON सिर्फ वस्तुओं या सरणियों के लिए नहीं है। निम्नलिखित आदिम प्रकार समर्थित हैं:

• स्ट्रिंग (उदाहरण के लिए "Hello World!" )
• संख्या (उदाहरण के लिए 42 )
• बूलियन (उदाहरण के लिए true )
• मान null

undefined इस अर्थ में समर्थित नहीं है कि अपरिभाषित संपत्ति को JSON से क्रमांकन पर छोड़ा जाएगा। इसलिए, JSON को निष्क्रिय करने और ऐसी संपत्ति के साथ समाप्त होने का कोई रास्ता नहीं है जिसका मूल्य undefined ।

स्ट्रिंग "42" वैध JSON है। JSON के पास हमेशा "{...}" या "[...]" बाहरी लिफाफा नहीं होता है।

जबकि nome JSON भी जावास्क्रिप्ट को मान्य करता है और कुछ JavaScript JSON को मान्य भी है, लेकिन दोनों भाषाओं के बीच कुछ सूक्ष्म अंतर हैं और न ही भाषा दूसरे का एक उपसमूह है।

एक उदाहरण के रूप में निम्नलिखित JSON स्ट्रिंग लें:

{"color": "blue"}

इसे सीधे जावास्क्रिप्ट में डाला जा सकता है। यह वाक्यात्मक रूप से मान्य होगा और सही मान देगा:

const skin = {"color": "blue"};

हालांकि, हम जानते हैं कि "रंग" एक वैध पहचानकर्ता नाम है और संपत्ति के नाम के आसपास के उद्धरण छोड़ा जा सकता है:

const skin = {color: "blue"};

हम यह भी जानते हैं कि हम दोहरे उद्धरण चिह्नों के बजाय एकल उद्धरणों का उपयोग कर सकते हैं:

const skin = {'color': 'blue'};

लेकिन, अगर हम इन दोनों को शाब्दिक रूप से लेते हैं और उन्हें JSON के रूप में मानते हैं, तो न तो वाक्यगत रूप से मान्य JSON होगा:

{color: "blue"}
{'color': 'blue'}

JSON को कड़ाई से सभी संपत्ति के नाम को डबल उद्धृत किया जाना चाहिए और स्ट्रिंग मानों को भी डबल उद्धृत किया जाना चाहिए।

JSON-newcomers के लिए जावास्क्रिप्ट के रूप में जावास्क्रिप्ट के साथ कोड अंश का उपयोग करने का प्रयास करना JSON के रूप में आम है, और JSON पार्सर से मिलने वाली सिंटैक्स त्रुटियों के बारे में अपने सिर को खरोंच करना।

गलत शब्दावली तब उत्पन्न होती है जब गलत शब्दावली को कोड में या बातचीत में लागू किया जाता है।

एक सामान्य एंटी-पैटर्न उन चरों को नाम देता है जो गैर-JSON मान को "json" के रूप में रखते हैं:

fetch(url).then(function (response) {
  const json = JSON.parse(response.data); // Confusion ensues!

  // We're done with the notion of "JSON" at this point,
  // but the concept stuck with the variable name.
});

उपरोक्त उदाहरण में, response.data एक JSON स्ट्रिंग है जिसे कुछ API द्वारा लौटाया जाता है। JSON HTTP प्रतिक्रिया डोमेन पर रुकता है। "Json" मिथ्या नाम वाला चर केवल एक जावास्क्रिप्ट मान रखता है (एक वस्तु, एक सरणी या एक साधारण संख्या भी हो सकती है!)

उपरोक्त लिखने का एक कम भ्रमित तरीका है:

fetch(url).then(function (response) {
  const value = JSON.parse(response.data);

  // We're done with the notion of "JSON" at this point.
  // You don't talk about JSON after parsing JSON.
});

डेवलपर्स बहुत से "JSON ऑब्जेक्ट" वाक्यांश को फेंक देते हैं। इससे भ्रम की स्थिति भी बनती है। क्योंकि जैसा कि ऊपर बताया गया है, JSON स्ट्रिंग में किसी ऑब्जेक्ट को मान के रूप में रखने की आवश्यकता नहीं होती है। "JSON स्ट्रिंग" एक बेहतर शब्द है। जैसे "XML स्ट्रिंग" या "YAML स्ट्रिंग"। आपको एक स्ट्रिंग मिलती है, आप इसे पार्स करते हैं, और आप एक मूल्य के साथ समाप्त होते हैं।

चक्रीय वस्तु मान

सभी वस्तुओं को JSON स्ट्रिंग में नहीं बदला जा सकता है। जब किसी ऑब्जेक्ट में चक्रीय आत्म-संदर्भ होते हैं, तो रूपांतरण विफल हो जाएगा।

यह आमतौर पर पदानुक्रमित डेटा संरचनाओं के लिए मामला है जहां माता-पिता और बच्चे दोनों एक-दूसरे का संदर्भ लेते हैं:

const world = {
  name: 'World',
  regions: []
};

world.regions.push({
  name: 'North America',
  parent: 'America'
});
console.log(JSON.stringify(world));
// {"name":"World","regions":[{"name":"North America","parent":"America"}]}

world.regions.push({
  name: 'Asia',
  parent: world
});

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

जैसे ही प्रक्रिया एक चक्र का पता लगाती है, अपवाद उठाया जाता है। यदि कोई चक्र पता नहीं था, तो स्ट्रिंग असीम रूप से लंबी होगी।