क्या आपने कभी ऑब्जेक्ट.एंट्रीज़ का उपयोग किया है और सोचा है कि यह कैसे काम करता है? यह आपके विचार से कहीं अधिक सरल है!

यहां एक बुनियादी कार्यान्वयन है:

function objectEntries(obj) {
  const entries = [];

  for (const key in obj) {
    if (Object.hasOwn(obj, key)) {
      entries.push([key, obj[key]]);
    }
  }

  return entries;
}

हालाँकि, यह कोड पर्याप्त अच्छा नहीं है - यदि वस्तु भारी हो तो क्या होगा? इस फ़ंक्शन को निष्पादित करने की पूरी प्रक्रिया के लिए सरणी आधारित दृष्टिकोण के प्रदर्शन को मेमोरी में संग्रहीत करना होगा। और यदि आप इसे दोबारा उपयोग करते हैं? इसे एक नई सारणी बनानी होगी और उसी तरह स्मृति में रखनी होगी। वास्तविक दुनिया में, इससे प्रदर्शन संबंधी गंभीर समस्याएं पैदा हो सकती हैं और कुछ बिंदु पर हमें प्रदर्शन के लिए समायोजन की आवश्यकता होगी। हालाँकि, एक शानदार समाधान है जो इन सभी समस्याओं का समाधान करेगा, जिसमें Symbol.iterator बचाव में आता है!

यहां एक अद्यतन स्निपेट है:

function objectEntries(obj) {
  return {
    [Symbol.iterator]() {
      const keys = Object.keys(obj);
      let index = 0;

      return {
        next() {
          if (index 



पुनरावृत्ति के लिए Symbol.iterator का उपयोग क्यों करें?

हमारे प्रारंभिक कार्यान्वयन में, objectEntries फ़ंक्शन मेमोरी में सभी प्रविष्टियों ([कुंजी, मान] जोड़े) की एक सरणी बनाता है, जो एक समस्या हो सकती है यदि ऑब्जेक्ट में बड़ी संख्या में गुण हों। सभी प्रविष्टियों को एक सरणी में संग्रहीत करने का मतलब है कि हमें प्रत्येक जोड़ी के लिए पहले से मेमोरी आवंटित करनी होगी। यह दृष्टिकोण छोटी वस्तुओं के लिए काफी हद तक ठीक है, लेकिन जैसे-जैसे वस्तु का आकार बढ़ता है यह जल्दी ही अप्रभावी और धीमा हो जाता है।

अद्यतन कोड में, हम एक ऑब्जेक्ट पर [Symbol.iterator] को परिभाषित करते हैं जो पुनरावृत्ति तर्क रखता है। आइए इसे चरण-दर-चरण तोड़ें:

• कुंजियाँ प्रारंभ करें: ऑब्जेक्ट.कीज़(ओबीजे) ऑब्जेक्ट ओबीजे से कुंजियों की एक सरणी प्राप्त करता है। कुंजियों की यह सूची हमें यह जानने की अनुमति देती है कि प्रत्येक प्रविष्टि को संग्रहीत किए बिना हमें किन संपत्तियों तक पहुंचने की आवश्यकता है।
• एक इंडेक्स पॉइंटर का उपयोग करें: एक वैरिएबल इंडेक्स कुंजी सरणी में हमारी वर्तमान स्थिति का ट्रैक रखता है। यह एकमात्र राज्य है जिसे हम लूप में शामिल करने जा रहे हैं।
• अगली विधि को परिभाषित करें: अगला() फ़ंक्शन वर्तमान कुंजी को पुनः प्राप्त करने और इसे बढ़ाने के लिए इंडेक्स का उपयोग करता है। यह प्रत्येक [कुंजी, ओबीजे[कुंजी]] जोड़ी को एक मान के रूप में लौटाता है, और जब हम सभी कुंजियों के माध्यम से पुनरावृत्त कर लेते हैं तो 'den: true' सेट कर देता है।
• ऐसा करने से, हम ऑब्जेक्टएंट्रीज़ को किसी भी लूप के साथ संगत होने में सक्षम बनाते हैं, बिना प्रविष्टियों की पूरी श्रृंखला बनाने की मेमोरी लागत के।

कस्टम लूप्स पर Symbol.iterator लागू करना

आइए गहराई से जानें कि कैसे ये विधियां लूप व्यवहार पर अधिक नियंत्रण प्रदान कर सकती हैं। प्रदान किया गया प्रत्येक उदाहरण सरणी डेटा के साथ इंटरैक्ट करने का एक अनूठा तरीका प्रदर्शित करता है, जो आपके कोड में बहुत अधिक लचीलापन जोड़ता है। हम प्रत्येक पद्धति के निहितार्थों का पता लगाएंगे और विभिन्न परिदृश्यों में उनका लाभ कैसे उठाया जा सकता है।

इन उदाहरणों में मैं अपने कोड को पढ़ने में आसान बनाने के लिए उदाहरण विधियों के साथ ऐरे प्रोटोटाइप (प्रोटोटाइप पर अधिक जानकारी यहां) का विस्तार करने जा रहा हूं। आइए सीधे अंदर कूदें!

उदाहरण के लिए, यह रिवर्सइटरेटर विधि चैट एप्लिकेशन जैसी किसी चीज़ में उपयोगी हो सकती है जहां आप सबसे हाल के संदेशों को पहले प्रदर्शित करना चाहेंगे। चैट एप्लिकेशन ढेर सारा डेटा (इस मामले में संदेश) रखने के लिए कुख्यात हैं। रिवर्सइटरेटर का उपयोग करके, आप संदेशों की एक सूची के माध्यम से पुनरावृत्त कर सकते हैं और एक नया उलटा सरणी बनाने की आवश्यकता के बिना उन्हें वांछित क्रम में प्रदर्शित कर सकते हैं।

Array.prototype.reverseIterator = function() {
  let index = this.length - 1;
  return {
    [Symbol.iterator]: () => ({
      next: () => {
        if (index >= 0) {
          return { value: this[index--], done: false };
        }
        return { done: true };
      }
    })
  };
};

const numbers = [1, 2, 3, 4, 5];
for (const num of numbers.reverseIterator()) {
  console.log(num); // 5, 4, 3, 2, 1
}

यह अनूठी विधि आपको एक सरणी के माध्यम से पुनरावृत्त करने में सक्षम बनाती है और यह सुनिश्चित करती है कि केवल अद्वितीय मान ही प्राप्त हों। यह पहले से फ़िल्टर किए बिना और अधिक मेमोरी का उपयोग किए बिना तुरंत डुप्लिकेट को खत्म करने के लिए बहुत उपयोगी है।

Array.prototype.unique = function() {
  const seen = new Set();
  return {
    [Symbol.iterator]: () => ({
      next: () => {
        for (let i = 0; i 



बड़े डेटासेट से निपटने के दौरान नीचे दी गई खंड विधि उपयोगी हो सकती है, आप मेमोरी उपयोग को कम करने और प्रदर्शन में सुधार करने के लिए उन्हें छोटे टुकड़ों में संसाधित कर सकते हैं। मान लीजिए कि आप CSV फ़ाइल जैसी किसी चीज़ से डेटा आयात कर रहे हैं, तो आप इसे अधिक स्केलेबल सेगमेंट में पढ़ और संसाधित कर सकते हैं। इसके अलावा, वेब यूजर इंटरफेस में, चंकिंग का उपयोग पेजिनेशन के लिए किया जा सकता है, जिससे आप प्रति पेज एक विशिष्ट संख्या में आइटम प्रदर्शित कर सकते हैं या अनंत लोडर को बेहतर ढंग से प्रबंधित करने में मदद कर सकते हैं।


Array.prototype.chunk = function(size) {
  let index = 0;
  return {
    [Symbol.iterator]: () => ({
      next: () => {
        if (index 



निष्कर्ष

इस लेख में, हमने पता लगाया कि कैसे Symbol.iterator तर्क को अनुकूलित करता है और हमारे लूप की दक्षता में सुधार करता है। Array.prototype (या उस प्रभाव के लिए किसी अन्य पुनरावर्तनीय) पर कस्टम पुनरावर्तनीय तरीकों को लागू करके, हम मेमोरी उपयोग को प्रभावी ढंग से प्रबंधित कर सकते हैं और नियंत्रित कर सकते हैं कि हमारा लूप कैसे चल रहा है।

ऑब्जेक्टएंट्रीज़ के प्रारंभिक उदाहरण ने प्रदर्शित किया कि कैसे एक सरणी-आधारित दृष्टिकोण बड़ी वस्तुओं को संभालते समय प्रदर्शन समस्याओं का कारण बन सकता है। हालाँकि, SYmbol.iterator का उपयोग करके, हमने एक कुशल समाधान बनाया जो हमें अनावश्यक मेमोरी आवंटन के ओवरहेड के बिना ऑब्जेक्ट प्रविष्टियों पर पुनरावृति करने की अनुमति देता है।

हमने कई व्यावहारिक उदाहरणों पर भी गौर किया कि कैसे Array.prototype का विस्तार विभिन्न वास्तविक दुनिया के परिदृश्यों को सुविधाजनक बना सकता है जिनसे डेवलपर्स को दिन-प्रतिदिन निपटना पड़ता है।

अपने पास मौजूद इन शक्तिशाली उपकरणों के साथ, आप अपने ऐप पर लगभग-शून्य प्रदर्शन प्रभाव के साथ जावास्क्रिप्ट में जटिल डेटा प्रबंधन परिदृश्यों को हल करने के लिए बेहतर ढंग से सुसज्जित हैं।