यह मेरे मित्र के साथ रिकर्सन के बारे में चर्चा के दौरान सामने आया। क्यों नहीं बनाते
पुनरावर्ती प्रोग्रामिंग अभ्यास के रूप में एक जावास्क्रिप्ट JSON.stringify विधि? बहुत अच्छा लगता है
विचार।

मैंने तुरंत पहला संस्करण तैयार कर लिया। और इसने भयानक प्रदर्शन किया!
आवश्यक समय मानक JSON.stringify से लगभग 4 गुना था।

पहला ड्राफ्ट

function json_stringify(obj) {
  if (typeof obj == "number" || typeof obj == "boolean") {
    return String(obj);
  }

  if (typeof obj == "string") {
    return `"${obj}"`;
  }

  if (Array.isArray(obj)) {
    return "["   obj.map(json_stringify).join(",")   "]";
  }

  if (typeof obj === "object") {
    const properties_str = Object.entries(obj)
      .map(([key, val]) => {
        return `"${key}":${json_stringify(val)}`;
      })
      .join(",");
    return "{"   properties_str   "}";
  }
}

निम्नलिखित को चलाकर, हम देख सकते हैं कि हमारा json_stringify इस प्रकार काम करता है
अपेक्षित।

const { assert } = require("console");
const test_obj = {
  name: "John Doe",
  age: 23,
  hobbies: ["football", "comet study"]
};

assert(json_stringify(test_obj) === JSON.stringify(test_obj))

अधिक परिदृश्यों का परीक्षण करने के लिए, और एक औसत विचार प्राप्त करने के लिए एकाधिक रन कि हमारा
स्क्रिप्ट चलती है, हमने एक सरल परीक्षण स्क्रिप्ट बनाई है!

एक सरल परीक्षण स्क्रिप्ट

function validity_test(fn1, fn2, test_values) {
  for (const test_value of test_values) {
    assert(fn1(test_value) == fn2(test_value));
  }
}

function time(fn, num_runs = 1, ...args) {
  const start_time = Date.now()

  for (let i = 0; i 


इसे चलाने पर हमें निम्न प्रकार का समय मिलता है।


Testing 1000 times
    Std lib JSON.stringify() took 5 ms
    Custom json_stringify() took 20 ms
Testing 10000 times
    Std lib JSON.stringify() took 40 ms
    Custom json_stringify() took 129 ms
Testing 100000 times
    Std lib JSON.stringify() took 388 ms
    Custom json_stringify() took 1241 ms
Testing 1000000 times
    Std lib JSON.stringify() took 3823 ms
    Custom json_stringify() took 12275 ms




यह अलग-अलग प्रणालियों पर अलग-अलग चल सकता है लेकिन लगने वाले समय का अनुपात 

std JSON.strngify द्वारा हमारे कस्टम json_stringify के बारे में 
 होना चाहिए
1:3 - 1:4

किसी दिलचस्प मामले में यह अलग भी हो सकता है। 
 के बारे में अधिक जानने के लिए आगे पढ़ें
वह!

  
  
  प्रदर्शन सुधारना


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

पुराने से नया ऐरे. वस्तुओं के हमारे मामले में, यह 
 की एक सरणी बना रहा है
JSON ने ऑब्जेक्ट प्रविष्टियों वाले सरणी से ऑब्जेक्ट गुणों को स्ट्रिंग किया।

ऐरे तत्वों के स्ट्रिंगिफिकेशन के साथ भी ऐसा ही हो रहा है।

हमें किसी सरणी में तत्वों, या किसी ऑब्जेक्ट की प्रविष्टियों पर लूप करना होगा! लेकिन

हम केवल JSON स्ट्रिंग भागों में शामिल होने के लिए एक और सरणी बनाना छोड़ सकते हैं।

यहां अद्यतन संस्करण है (संक्षिप्तता के लिए केवल बदले हुए हिस्से दिखाए गए हैं)


function json_stringify(val) {
  if (typeof val === "number" || typeof val === "boolean") {
    return String(val);
  }

  if (typeof val === "string") {
    return `"${val}"`;
  }

  if (Array.isArray(val)) {
    let elements_str = "["

    let sep = ""
    for (const element of val) {
      elements_str  = sep   json_stringify(element)
      sep = ","
    }
    elements_str  = "]"

    return elements_str
  }

  if (typeof val === "object") {
    let properties_str = "{"

    let sep = ""
    for (const key in val) {
      properties_str  = sep   `"${key}":${json_stringify(val[key])}`
      sep = ","
    }
    properties_str  = "}"

    return properties_str;
  }
}




और अब परीक्षण स्क्रिप्ट का आउटपुट यहां है


Testing 1000 times
        Std lib JSON.stringify() took 5 ms
        Custom json_stringify() took 6 ms
Testing 10000 times
        Std lib JSON.stringify() took 40 ms
        Custom json_stringify() took 43 ms
Testing 100000 times
        Std lib JSON.stringify() took 393 ms
        Custom json_stringify() took 405 ms
Testing 1000000 times
        Std lib JSON.stringify() took 3888 ms
        Custom json_stringify() took 3966 ms




यह अब काफी बेहतर दिखता है। हमारा कस्टम json_stringify केवल 3 एमएस ले रहा है

किसी गहरे नेस्टेड ऑब्जेक्ट को 10,000 बार स्ट्रिंग करने के लिए JSON.stringify से अधिक।

हालाँकि यह सही नहीं है, यह एक स्वीकार्य देरी है।

  
  
  और अधिक निचोड़ना??


वर्तमान विलंब सभी स्ट्रिंग निर्माण और संयोजन के कारण हो सकता है 

ऐसा हो रहा है. हर बार जब हम element_str = sep json_stringify(element)
 चलाते हैं
हम 3 तारों को जोड़ रहे हैं।

स्ट्रिंग्स को जोड़ना महंगा है क्योंकि इसके लिए इसकी आवश्यकता होती है

संपूर्ण संयुक्त स्ट्रिंग को फिट करने के लिए एक नया स्ट्रिंग बफर बनाना
नए बनाए गए बफ़र में अलग-अलग स्ट्रिंग्स की प्रतिलिपि बनाएँ
स्वयं बफ़र का उपयोग करके और वहां सीधे डेटा लिखने से हमें मिल सकता है

एक प्रदर्शन में सुधार. चूँकि हम एक बड़ा बफ़र (जैसे 80 अक्षर) बना सकते हैं

और फिर जब यह खत्म हो जाए तो 80 वर्णों को फिट करने के लिए नए बफ़र्स बनाएं।

हम डेटा के पुन:आबंटन/प्रतिलिपि को पूरी तरह से नहीं टालेंगे, लेकिन हम करेंगे

उन परिचालनों को कम करना।

एक और संभावित देरी पुनरावर्ती प्रक्रिया ही है! विशेष रूप से

फ़ंक्शन कॉल जिसमें समय लगता है। हमारे फ़ंक्शन कॉल json_stringify(val)
 पर विचार करें
जिसका सिर्फ एक पैरामीटर है।

  
  
  फ़ंक्शन कॉल को समझना


ये कदम होंगे

रिटर्न एड्रेस को स्टैक पर पुश करें
तर्क संदर्भ को स्टैक पर धकेलें
बुलाए गए फ़ंक्शन में

स्टैक से पैरामीटर संदर्भ पॉप करें
स्टैक से रिटर्न पता पॉप करें
स्टैक पर रिटर्न वैल्यू (स्ट्रिफाइड भाग) को पुश करें

कॉलिंग फ़ंक्शन में

स्टैक से फ़ंक्शन द्वारा लौटाए गए मान को पॉप ऑफ करें

ये सभी ऑपरेशन फ़ंक्शन कॉल सुनिश्चित करने के लिए होते हैं और यह सीपीयू जोड़ता है

लागत.

यदि हम json_stringify का एक गैर-पुनरावर्ती एल्गोरिदम बनाते हैं तो इन सभी परिचालनों को निष्पादित करें

फ़ंक्शन कॉल के लिए ऊपर सूचीबद्ध (ऐसी कॉल की संख्या का गुना) होगा

कोई नहीं रह गया।

यह एक भविष्य का प्रयास हो सकता है। 

  
  
  NodeJs संस्करण अंतर


यहाँ ध्यान देने योग्य एक आखिरी बात। परीक्षण स्क्रिप्ट के निम्नलिखित आउटपुट पर विचार करें


Testing 1000 times
        Std lib JSON.stringify() took 8 ms
        Custom json_stringify() took 8 ms
Testing 10000 times
        Std lib JSON.stringify() took 64 ms
        Custom json_stringify() took 51 ms
Testing 100000 times
        Std lib JSON.stringify() took 636 ms
        Custom json_stringify() took 467 ms
Testing 1000000 times
        Std lib JSON.stringify() took 6282 ms
        Custom json_stringify() took 4526 ms




क्या हमारा कस्टम json_stringify NodeJs मानक से बेहतर प्रदर्शन करता है

JSON.stringify???

पूर्ण रूप से हाँ! लेकिन यह NodeJs (v18.20.3) का पुराना संस्करण है। पता चला, के लिए

यह संस्करण (और संभवतः निचला भी) हमारा कस्टम मेड json_stringify काम करता है

मानक लाइब्रेरी से तेज़!

इस लेख के सभी परीक्षण (इस अंतिम को छोड़कर) 
 के साथ किए गए हैं
नोड v22.6.0

JSON.stringify का प्रदर्शन v18 से बढ़कर v22 हो गया है। यह बहुत बढ़िया है

यह भी ध्यान रखना महत्वपूर्ण है कि, हमारी स्क्रिप्ट ने NodeJs v22 में बेहतर प्रदर्शन किया।

तो, इसका मतलब है, NodeJs ने रनटाइम के समग्र प्रदर्शन में भी वृद्धि की है।

संभवतः अंतर्निहित V8 इंजन में ही एक अद्यतन हुआ है।

खैर, यह मेरे लिए एक सुखद अनुभव रहा है। और मुझे आशा है कि यह
 के लिए होगा
आप भी। और इस सारे आनंद के बीच, हमने एक या दो चीज़ें सीखीं!

निर्माण करते रहें, परीक्षण करते रहें!