जावास्क्रिप्टमधील कस्टम इटरेशन अनलॉक करणे: इटररेटर प्रोटोकॉलचा सखोल अभ्यास

इटरेशन (Iteration) ही प्रोग्रामिंगमधील सर्वात मूलभूत संकल्पनांपैकी एक आहे. यादीतील आयटम्सवर प्रक्रिया करण्यापासून ते डेटा स्ट्रीम्स वाचण्यापर्यंत, आपण सतत माहितीच्या क्रमांसोबत काम करत असतो. जावास्क्रिप्टमध्ये, आपल्याकडे for...of लूप आणि स्प्रेड सिंटॅक्स (...) सारखी शक्तिशाली आणि सुंदर साधने आहेत, जी Arrays, Strings, आणि Maps सारख्या बिल्ट-इन प्रकारांवर इटरेशन करणे सोपे करतात.

पण तुम्ही कधी विचार केला आहे का की या ऑब्जेक्ट्सना इतके खास काय बनवते? तुम्ही for (const char of "hello") असे का लिहू शकता, पण for (const prop of {a: 1, b: 2}) असे का नाही? याचे उत्तर ECMAScript मानकाच्या एका शक्तिशाली, पण अनेकदा गैरसमजल्या जाणाऱ्या वैशिष्ट्यात दडलेले आहे: इटररेटर प्रोटोकॉल (the Iterator Protocol).

हा प्रोटोकॉल केवळ जावास्क्रिप्टच्या बिल्ट-इन ऑब्जेक्ट्ससाठी एक अंतर्गत यंत्रणा नाही. हे एक खुले मानक आहे, एक करार आहे जो कोणताही ऑब्जेक्ट स्वीकारू शकतो. हा प्रोटोकॉल लागू करून, तुम्ही जावास्क्रिप्टला तुमच्या स्वतःच्या कस्टम ऑब्जेक्ट्सवर कसे इटरेशन करायचे हे शिकवू शकता, ज्यामुळे ते भाषेमध्ये फर्स्ट-क्लास सिटीझन बनतात. तुम्ही तुमच्या कस्टम डेटा स्ट्रक्चर्ससाठी, जसे की बायनरी ट्री, लिंक्ड लिस्ट, गेमचा टर्न सिक्वेन्स किंवा घटनांची टाइमलाइन, for...of सारखीच सिंटॅक्टिक सुंदरता अनलॉक करू शकता.

या सर्वसमावेशक मार्गदर्शकामध्ये, आपण इटररेटर प्रोटोकॉलचे रहस्य उलगडणार आहोत. आपण त्याचे मूळ घटक समजून घेऊ, सुरवातीपासून कस्टम इटररेटर कसे बनवायचे ते पाहू, अनंत क्रम (infinite sequences) सारख्या प्रगत वापराच्या केसेसचा शोध घेऊ आणि शेवटी, जनरेटर फंक्शन्स वापरून आधुनिक, सोपी पद्धत शोधू. याच्या शेवटी, तुम्हाला केवळ इटरेशन कसे कार्य करते हे समजणार नाही, तर तुम्ही अधिक प्रभावी, पुन्हा वापरण्यायोग्य आणि मुहावरेदार (idiomatic) जावास्क्रिप्ट कोड लिहिण्यास सक्षम व्हाल.

इटरेशनचा गाभा: जावास्क्रिप्ट इटररेटर प्रोटोकॉल काय आहे?

सर्वप्रथम, हे समजून घेणे महत्त्वाचे आहे की "इटररेटर प्रोटोकॉल" हा तुम्ही विस्तारित (extend) करू शकाल असा एकच क्लास किंवा तुम्ही कॉल करू शकाल असे विशिष्ट फंक्शन नाही. हा नियमांचा किंवा संकेतांचा एक संच आहे ज्याचे पालन ऑब्जेक्टने "इटरेबल" मानले जाण्यासाठी आणि "इटररेटर" तयार करण्यासाठी केले पाहिजे. याला एक करार (contract) म्हणून पाहणे उत्तम आहे. जर तुमचा ऑब्जेक्ट या करारावर स्वाक्षरी करतो, तर जावास्क्रिप्ट इंजिन त्यावर लूप कसे करायचे हे जाणण्याचे वचन देते.

हा करार दोन वेगळ्या भागांमध्ये विभागलेला आहे:

1. इटरेबल प्रोटोकॉल (The Iterable Protocol): हे ठरवते की एखादा ऑब्जेक्ट मुळात इटरेबल आहे की नाही.
2. इटररेटर प्रोटोकॉल (The Iterator Protocol): हे ठरवते की ऑब्जेक्टवर एका वेळी एक व्हॅल्यू घेऊन कसे इटरेशन केले जाईल.

चला या कराराच्या प्रत्येक भागाचे तपशीलवार परीक्षण करूया.

कराराचा पहिला अर्धा भाग: इटरेबल प्रोटोकॉल

इटरेबल प्रोटोकॉल आश्चर्यकारकपणे सोपा आहे. त्याची फक्त एकच आवश्यकता आहे:

एखादा ऑब्जेक्ट इटरेबल मानला जातो जर त्याच्याकडे एक विशिष्ट, सुप्रसिद्ध प्रॉपर्टी असेल जी इटररेटर मिळवण्यासाठी एक मेथड प्रदान करते. ही सुप्रसिद्ध प्रॉपर्टी Symbol.iterator वापरून ॲक्सेस केली जाते.

म्हणून, एखाद्या ऑब्जेक्टला इटरेबल होण्यासाठी, त्याच्याकडे [Symbol.iterator] की द्वारे ॲक्सेस करण्यायोग्य एक मेथड असणे आवश्यक आहे. जेव्हा ही मेथड कॉल केली जाते, तेव्हा तिने एक इटररेटर ऑब्जेक्ट (ज्याबद्दल आपण पुढील विभागात चर्चा करू) परत करणे आवश्यक आहे.

तुम्ही कदाचित विचारत असाल, "`Symbol` म्हणजे काय, आणि 'iterator' सारखे स्ट्रिंग नाव का वापरले जात नाही?" `Symbol` हा ES6 मध्ये सादर केलेला एक युनिक आणि अपरिवर्तनीय (immutable) प्रिमिटीव्ह डेटा प्रकार आहे. त्याचा प्राथमिक उद्देश ऑब्जेक्ट प्रॉपर्टीजसाठी एक युनिक की म्हणून काम करणे आहे, ज्यामुळे नावांच्या अपघाती टक्कर (collisions) टाळता येतात. जर प्रोटोकॉलने 'iterator' सारखी साधी स्ट्रिंग वापरली असती, तर तुमच्या स्वतःच्या कोडमध्ये कदाचित त्याच नावाची प्रॉपर्टी वेगळ्या उद्देशासाठी परिभाषित केली गेली असती, ज्यामुळे अनपेक्षित बग्स येऊ शकतात. Symbol.iterator वापरून, भाषेचे स्पेसिफिकेशन एक युनिक, प्रमाणित की ची हमी देते जी इतर कोडशी टक्कर देणार नाही.

आपण हे बिल्ट-इन इटरेबल्सवर सहजपणे तपासू शकतो:

            const anArray = [1, 2, 3];
const aString = "global";
const aMap = new Map();

console.log(typeof anArray[Symbol.iterator]); // "function"
console.log(typeof aString[Symbol.iterator]); // "function"
console.log(typeof aMap[Symbol.iterator]);   // "function"

// A plain object is not iterable by default
const anObject = { a: 1, b: 2 };
console.log(typeof anObject[Symbol.iterator]); // "undefined"

            

              
                Copy
              
            
          

कराराचा दुसरा अर्धा भाग: इटररेटर प्रोटोकॉल

एकदा ऑब्जेक्टने [Symbol.iterator]() मेथड प्रदान करून तो इटरेबल असल्याचे सिद्ध केले की, लक्ष त्या मेथडने परत केलेल्या ऑब्जेक्टवर केंद्रित होते: इटररेटर (iterator). इटररेटर हा खरा कार्यवाहक आहे; तोच ऑब्जेक्ट आहे जो प्रत्यक्षात इटरेशन प्रक्रिया व्यवस्थापित करतो आणि व्हॅल्यूजचा क्रम तयार करतो.

इटररेटर प्रोटोकॉल देखील खूप सरळ आहे. त्याची एकच आवश्यकता आहे:

एखादा ऑब्जेक्ट इटररेटर असतो जर त्याच्याकडे next() नावाची मेथड असेल. ही next() मेथड, जेव्हा कॉल केली जाते, तेव्हा तिने दोन विशिष्ट प्रॉपर्टीज असलेला एक ऑब्जेक्ट परत केला पाहिजे:

• done (बुलियन): ही प्रॉपर्टी इटरेशनची स्थिती दर्शवते. जर क्रमामध्ये आणखी व्हॅल्यूज येणार असतील तर ती false असते. इटरेशन पूर्ण झाल्यावर ती true होते.
• value (कोणताही प्रकार): या प्रॉपर्टीमध्ये क्रमातील सध्याची व्हॅल्यू असते. जेव्हा done true असते, तेव्हा value प्रॉपर्टी वैकल्पिक असते आणि सामान्यतः undefined असते.

चला, कोणत्याही इटरेबल ऑब्जेक्टपासून पूर्णपणे वेगळा, हाताने तयार केलेला एक स्वतंत्र इटररेटर पाहूया. हा इटररेटर फक्त 1 ते 3 पर्यंत मोजेल.

            const manualCounterIterator = {
  count: 1,
  next: function() {
    if (this.count <= 3) {
      return { value: this.count++, done: false };
    } else {
      return { value: undefined, done: true };
    }
  }
};

// We call next() repeatedly to get each value
console.log(manualCounterIterator.next()); // { value: 1, done: false }
console.log(manualCounterIterator.next()); // { value: 2, done: false }
console.log(manualCounterIterator.next()); // { value: 3, done: false }
console.log(manualCounterIterator.next()); // { value: undefined, done: true }
console.log(manualCounterIterator.next()); // { value: undefined, done: true } - It stays done

            

              
                Copy
              
            
          

हीच ती मूलभूत यंत्रणा आहे जी प्रत्येक for...of लूपला शक्ती देते. जेव्हा तुम्ही for (const item of iterable) लिहिता, तेव्हा जावास्क्रिप्ट इंजिन पडद्यामागे खालील गोष्टी करते:

1. ते इटररेटर मिळवण्यासाठी iterable ऑब्जेक्टवर [Symbol.iterator]() मेथड कॉल करते.
2. त्यानंतर ते त्या इटररेटरवर वारंवार next() मेथड कॉल करते.
3. प्रत्येक परत आलेल्या ऑब्जेक्टसाठी जिथे done false आहे, ते value तुमच्या लूप व्हेरिएबलला (item) नियुक्त करते आणि लूप बॉडी कार्यान्वित करते.
4. जेव्हा next() असा ऑब्जेक्ट परत करते जिथे done true आहे, तेव्हा लूप समाप्त होतो.

सुरवातीपासून तयार करणे: कस्टम इटरेशनसाठी एक व्यावहारिक मार्गदर्शक

आता आपण सिद्धांत समजून घेतला आहे, चला ते प्रत्यक्षात आणूया. आपण Timeline नावाचा एक कस्टम क्लास तयार करू. हा क्लास ऐतिहासिक घटनांचा संग्रह व्यवस्थापित करेल आणि आपले ध्येय त्याला थेट इटरेबल बनवणे आहे, ज्यामुळे आपण घटनांमधून कालक्रमानुसार लूप करू शकू.

उपयोग केस: एक `Timeline` क्लास

आपला Timeline क्लास इव्हेंट्स संग्रहित करेल, प्रत्येक इव्हेंट year आणि description सह एक ऑब्जेक्ट असेल. आम्हाला या इव्हेंट्समधून वर्षानुसार क्रमवारी लावून for...of लूप वापरता यावा अशी आमची इच्छा आहे.

            class Timeline {
  constructor() {
    this.events = [];
  }

  addEvent(year, description) {
    this.events.push({ year, description });
  }
}

const myTimeline = new Timeline();
myTimeline.addEvent(1995, "JavaScript is created");
myTimeline.addEvent(2009, "Node.js is introduced");
myTimeline.addEvent(1997, "ECMAScript standard is first published");
myTimeline.addEvent(2015, "ES6 (ECMAScript 2015) is released");

// Goal: Make the following code work
// for (const event of myTimeline) {
//   console.log(`${event.year}: ${event.description}`);
// }

            

              
                Copy
              
            
          

चरण-दर-चरण अंमलबजावणी

आपले ध्येय साध्य करण्यासाठी, आपल्याला इटररेटर प्रोटोकॉल लागू करणे आवश्यक आहे. याचा अर्थ आपल्या Timeline क्लासमध्ये [Symbol.iterator]() मेथड जोडणे.

या मेथडला एक नवीन ऑब्जेक्ट—इटररेटर—परत करणे आवश्यक आहे, ज्यामध्ये next() मेथड असेल आणि तो इटरेशनची स्थिती (state) व्यवस्थापित करेल (उदा. आपण सध्या कोणत्या इव्हेंटवर आहोत). हे एक महत्त्वाचे डिझाइन तत्व आहे की इटरेशनची स्थिती इटरेबल ऑब्जेक्टवर न राहता, इटररेटरवर राहिली पाहिजे. यामुळे एकाच टाइमलाइनवर एकाच वेळी अनेक, स्वतंत्र इटरेशन्स शक्य होतात.

            class Timeline {
  constructor() {
    this.events = [];
  }

  addEvent(year, description) {
    // We'll add a simple check to ensure data integrity
    if (typeof year !== 'number' || typeof description !== 'string') {
      throw new Error("Invalid event data");
    }
    this.events.push({ year, description });
  }

  // Step 1: Implement the Iterable Protocol
  [Symbol.iterator]() {
    // Sort the events chronologically for iteration.
    // We create a copy to not mutate the original array's order.
    const sortedEvents = [...this.events].sort((a, b) => a.year - b.year);
    let currentIndex = 0;

    // Step 2: Return the iterator object
    return {
      // Step 3: Implement the Iterator Protocol with the next() method
      next: () => { // Using an arrow function to capture `sortedEvents` and `currentIndex`
        if (currentIndex < sortedEvents.length) {
          // There are more events to iterate over
          const currentEvent = sortedEvents[currentIndex];
          currentIndex++;
          return { value: currentEvent, done: false };
        } else {
          // We have reached the end of the events
          return { value: undefined, done: true };
        }
      }
    };
  }
}

            

              
                Copy
              
            
          

जादू पाहणे: आपला कस्टम इटरेबल वापरणे

प्रोटोकॉल योग्यरित्या लागू केल्यामुळे, आपला Timeline ऑब्जेक्ट आता एक पूर्ण विकसित इटरेबल आहे. तो जावास्क्रिप्टच्या इटरेशन-आधारित भाषा वैशिष्ट्यांसह सहजपणे एकत्रित होतो. चला ते कृतीत पाहूया.

            const myTimeline = new Timeline();
myTimeline.addEvent(1995, "JavaScript is created");
myTimeline.addEvent(2009, "Node.js is introduced");
myTimeline.addEvent(1997, "ECMAScript standard is first published");
myTimeline.addEvent(2015, "ES6 (ECMAScript 2015) is released");

console.log("--- Using for...of loop ---");
for (const event of myTimeline) {
  console.log(`${event.year}: ${event.description}`);
}
// Output:
// 1995: JavaScript is created
// 1997: ECMAScript standard is first published
// 2009: Node.js is introduced
// 2015: ES6 (ECMAScript 2015) is released

console.log("\n--- Using spread syntax ---");
const eventsArray = [...myTimeline];
console.log(eventsArray);
// Output: An array of the event objects, sorted by year

console.log("\n--- Using Array.from() ---");
const eventsFrom = Array.from(myTimeline);
console.log(eventsFrom);
// Output: An array of the event objects, sorted by year

console.log("\n--- Using destructuring assignment ---");
const [firstEvent, secondEvent] = myTimeline;
console.log(firstEvent);
// Output: { year: 1995, description: 'JavaScript is created' }
console.log(secondEvent);
// Output: { year: 1997, description: 'ECMAScript standard is first published' }

            

              
                Copy
              
            
          

हीच प्रोटोकॉलची खरी शक्ती आहे. एका मानक कराराचे पालन करून, आपण आपल्या कस्टम ऑब्जेक्टला कोणत्याही अतिरिक्त कामाशिवाय विद्यमान आणि भविष्यातील जावास्क्रिप्ट वैशिष्ट्यांच्या विशाल श्रेणीशी सुसंगत बनवले आहे.

तुमचे इटरेशन कौशल्य वाढवणे

आता तुम्ही मूलभूत गोष्टींमध्ये पारंगत झाला आहात, चला काही अधिक प्रगत संकल्पनांचा शोध घेऊया ज्या तुम्हाला आणखी जास्त नियंत्रण आणि लवचिकता देतात.

स्टेट आणि स्वतंत्र इटररेटरचे महत्त्व

आमच्या Timeline उदाहरणामध्ये, आम्ही इटरेशनची स्थिती (currentIndex आणि sortedEvents कॉपी) [Symbol.iterator]() द्वारे परत केलेल्या इटररेटर ऑब्जेक्टमध्ये ठेवण्याची खूप काळजी घेतली. हे इतके महत्त्वाचे का आहे? कारण हे सुनिश्चित करते की प्रत्येक वेळी जेव्हा आपण इटरेशन सुरू करतो, तेव्हा आपल्याला एक *नवीन, स्वतंत्र इटररेटर* मिळतो.

यामुळे अनेक उपभोक्ते एकाच इटरेबल ऑब्जेक्टवर एकमेकांमध्ये हस्तक्षेप न करता इटरेशन करू शकतात. कल्पना करा की जर currentIndex ही Timeline इन्स्टन्सचीच एक प्रॉपर्टी असती—तर गोंधळ झाला असता!

            const sharedTimeline = new Timeline();
sharedTimeline.addEvent(1, 'Event A');
sharedTimeline.addEvent(2, 'Event B');
sharedTimeline.addEvent(3, 'Event C');

const iterator1 = sharedTimeline[Symbol.iterator]();
const iterator2 = sharedTimeline[Symbol.iterator]();

console.log(iterator1.next().value); // { year: 1, description: 'Event A' }
console.log(iterator2.next().value); // { year: 1, description: 'Event A' } (Starts its own iteration)
console.log(iterator1.next().value); // { year: 2, description: 'Event B' } (Unaffected by iterator2)

            

              
                Copy
              
            
          

अनंतकडे जाणे: अंतहीन क्रम तयार करणे

इटररेटर प्रोटोकॉलला इटरेशन कधीतरी संपण्याची आवश्यकता नाही. done प्रॉपर्टी कायमस्वरूपी false राहू शकते. यामुळे आपल्याला अनंत क्रम मॉडेल करण्याची परवानगी मिळते, जे युनिक आयडी तयार करणे, यादृच्छिक डेटाचे प्रवाह तयार करणे किंवा गणितीय क्रम मॉडेल करणे यासारख्या कामांसाठी अत्यंत उपयुक्त असू शकते.

चला एक इटररेटर तयार करूया जो फिबोनाची क्रम (Fibonacci sequence) अनिश्चित काळासाठी तयार करतो.

            const fibonacciSequence = {
  [Symbol.iterator]() {
    let a = 0, b = 1;
    return {
      next() {
        [a, b] = [b, a + b];
        return { value: a, done: false };
      }
    };
  }
};

// We can't use spread syntax or Array.from() here, as that would create an infinite loop and crash!
// const fibArray = [...fibonacciSequence]; // DANGER: Infinite loop!

// We must consume it carefully, providing our own termination condition.
console.log("First 10 Fibonacci numbers:");
let count = 0;
for (const number of fibonacciSequence) {
  console.log(number);
  count++;
  if (count >= 10) {
    break; // It's crucial to break out of the loop!
  }
}

            

              
                Copy
              
            
          

पर्यायी इटररेटर मेथड्स: `return()`

अधिक प्रगत परिस्थितींसाठी, विशेषतः संसाधन व्यवस्थापनाशी संबंधित (जसे की फाइल हँडल किंवा नेटवर्क कनेक्शन), इटररेटरमध्ये वैकल्पिकरित्या return() मेथड असू शकते. ही मेथड जावास्क्रिप्ट इंजिनद्वारे आपोआप कॉल केली जाते जर इटरेशन वेळेपूर्वी थांबवले गेले. हे तेव्हा होऊ शकते जेव्हा break, return, किंवा throw स्टेटमेंट for...of लूप पूर्ण होण्यापूर्वीच बाहेर पडते.

हे तुमच्या इटररेटरला साफसफाईची कामे करण्याची संधी देते.

            function createResourceIterator() {
  let resourceIsOpen = true;
  console.log("Resource opened.");
  let i = 0;

  return {
    next() {
      if (i < 3) {
        return { value: ++i, done: false };
      } else {
        console.log("Iterator finished naturally.");
        resourceIsOpen = false;
        console.log("Resource closed.");
        return { done: true };
      }
    },
    return() {
      if (resourceIsOpen) {
        console.log("Iterator terminated early. Closing resource.");
        resourceIsOpen = false;
      }
      return { done: true }; // Must return a valid iterator result
    }
  };
}

console.log("--- Early exit scenario ---");
const resourceIterable = { [Symbol.iterator]: createResourceIterator };
for (const value of resourceIterable) {
  console.log(`Processing value: ${value}`);
  if (value > 1) {
    break; // This will trigger the return() method
  }
}

            

              
                Copy
              
            
          

टीप: त्रुटी प्रसारासाठी (error propagation) एक throw() मेथड देखील आहे, परंतु ती प्रामुख्याने जनरेटर फंक्शन्सच्या संदर्भात वापरली जाते, ज्यावर आपण पुढे चर्चा करणार आहोत.

आधुनिक दृष्टिकोन: जनरेटर फंक्शन्ससह सरलीकरण

आपण पाहिल्याप्रमाणे, इटररेटर प्रोटोकॉल मॅन्युअली लागू करण्यासाठी काळजीपूर्वक स्टेट मॅनेजमेंट आणि इटररेटर ऑब्जेक्ट तयार करण्यासाठी आणि { value, done } ऑब्जेक्ट्स परत करण्यासाठी बॉयलरप्लेट कोडची आवश्यकता असते. ही प्रक्रिया समजून घेणे आवश्यक असले तरी, ES6 ने एक अधिक सुंदर उपाय सादर केला आहे: जनरेटर फंक्शन्स (generator functions).

जनरेटर फंक्शन हे एक विशेष प्रकारचे फंक्शन आहे जे थांबवले आणि पुन्हा सुरू केले जाऊ शकते, ज्यामुळे ते कालांतराने व्हॅल्यूजचा एक क्रम तयार करू शकते. हे इटररेटर तयार करणे प्रचंड सोपे करते.

मुख्य सिंटॅक्स:

• function*: तारका चिन्ह (*) फंक्शनला जनरेटर म्हणून घोषित करते.
• yield: हा कीवर्ड जनरेटरची अंमलबजावणी थांबवतो आणि एक व्हॅल्यू "yields" (देतो) करतो. जेव्हा इटररेटरची next() मेथड पुन्हा कॉल केली जाते, तेव्हा फंक्शन जिथे थांबले होते तिथून पुन्हा सुरू होते.

जेव्हा तुम्ही जनरेटर फंक्शन कॉल करता, तेव्हा ते त्याची बॉडी त्वरित कार्यान्वित करत नाही. त्याऐवजी, ते एक इटररेटर ऑब्जेक्ट परत करते जे प्रोटोकॉलशी पूर्णपणे सुसंगत असते. जावास्क्रिप्ट इंजिन आपोआप स्टेट मशीन, next() मेथड आणि तुमच्यासाठी { value, done } ऑब्जेक्ट्सची निर्मिती हाताळते.

आपल्या `Timeline` उदाहरणाचे रिफॅक्टरिंग

चला पाहूया की जनरेटर फंक्शन्स आपल्या Timeline अंमलबजावणीला किती नाट्यमयरित्या सोपे करू शकतात. लॉजिक तेच राहते, परंतु कोड अधिक वाचनीय आणि कमी त्रुटी-प्रवण बनतो.

            class Timeline {
  constructor() {
    this.events = [];
  }

  addEvent(year, description) {
    this.events.push({ year, description });
  }

  // Refactored with a generator function!
  *[Symbol.iterator]() { // The asterisk makes this a generator method
    // Create a sorted copy
    const sortedEvents = [...this.events].sort((a, b) => a.year - b.year);

    // Loop through the sorted events
    for (const event of sortedEvents) {
      // yield pauses the function and returns the value
      yield event;
    }
    // When the function finishes, the iterator is automatically marked as 'done'
  }
}

// Usage is exactly the same, but the implementation is cleaner!
const myGenTimeline = new Timeline();
myGenTimeline.addEvent(2002, "The Euro currency is introduced");
myGenTimeline.addEvent(1998, "Google is founded");

for (const event of myGenTimeline) {
  console.log(`${event.year}: ${event.description}`);
}

            

              
                Copy
              
            
          

फरक बघा! इटररेटर ऑब्जेक्टची गुंतागुंतीची मॅन्युअल निर्मिती नाहीशी झाली आहे. स्थिती (आपण कोणत्या इव्हेंटवर आहोत) जनरेटर फंक्शनच्या थांबलेल्या स्थितीद्वारे अप्रत्यक्षपणे व्यवस्थापित केली जाते. इटररेटर प्रोटोकॉल लागू करण्याचा हा आधुनिक, पसंतीचा मार्ग आहे.

`yield*` ची शक्ती

जनरेटर फंक्शन्समध्ये आणखी एक महाशक्ती आहे: yield* (yield star). हे एका जनरेटरला इटरेशन प्रक्रिया दुसऱ्या इटरेबल ऑब्जेक्टकडे सोपविण्यास अनुमती देते. हे अनेक स्त्रोतांकडून इटररेटर तयार करण्यासाठी एक अविश्वसनीयपणे शक्तिशाली साधन आहे.

कल्पना करा की आपल्याकडे एक `Project` क्लास आहे ज्यात अनेक `Timeline` ऑब्जेक्ट्स आहेत (उदा. एक डिझाइनसाठी, एक डेव्हलपमेंटसाठी). आपण `Project` लाच इटरेबल बनवू शकतो, आणि ते त्याच्या सर्व टाइमलाइन्समधील सर्व इव्हेंट्सवर क्रमाने सहजपणे इटरेशन करेल.

            class Project {
  constructor(name) {
    this.name = name;
    this.designTimeline = new Timeline();
    this.devTimeline = new Timeline();
  }

  *[Symbol.iterator]() {
    console.log(`Iterating through events for project: ${this.name}`);
    console.log("--- Design Events ---");
    yield* this.designTimeline; // Delegate to the design timeline's iterator
    
    console.log("--- Development Events ---");
    yield* this.devTimeline;  // Then delegate to the dev timeline's iterator
  }
}

const websiteProject = new Project("Global Website Relaunch");
websiteProject.designTimeline.addEvent(2023, "Initial wireframes created");
websiteProject.designTimeline.addEvent(2024, "Final brand guide approved");

websiteProject.devTimeline.addEvent(2024, "Backend API developed");
websiteProject.devTimeline.addEvent(2025, "Frontend deployment");

for (const event of websiteProject) {
  console.log(`  - ${event.year}: ${event.description}`);
}

            

              
                Copy
              
            
          

मोठे चित्र: इटररेटर प्रोटोकॉल आधुनिक जावास्क्रिप्टचा आधारस्तंभ का आहे

इटररेटर प्रोटोकॉल हा केवळ एक शैक्षणिक कुतूहल किंवा लायब्ररी लेखकांसाठी एक वैशिष्ट्य नाही. हे एक मूलभूत डिझाइन पॅटर्न आहे जे आंतरकार्यक्षमता (interoperability) आणि सुंदर कोडला प्रोत्साहन देते. याला एक युनिव्हर्सल अडॅप्टर म्हणून विचार करा. आपल्या ऑब्जेक्ट्सना या मानकाशी सुसंगत बनवून, आपण त्यांना भाषा वैशिष्ट्यांच्या एका मोठ्या इकोसिस्टममध्ये जोडता जे कोणत्याही डेटाच्या क्रमासोबत काम करण्यासाठी डिझाइन केलेले आहेत.

इटरेबल प्रोटोकॉलवर अवलंबून असलेल्या वैशिष्ट्यांची यादी मोठी आहे आणि वाढत आहे:

• लूप्स: for...of
• ॲरे निर्मिती/जोडणी: स्प्रेड सिंटॅक्स ([...iterable]) आणि Array.from(iterable)
• डेटा स्ट्रक्चर्स: new Map(iterable), new Set(iterable), new WeakMap(iterable), आणि new WeakSet(iterable) चे कन्स्ट्रक्टर्स सर्व इटरेबल्स स्वीकारतात.
• असિંक्रोनस ऑपरेशन्स: Promise.all(iterable), Promise.race(iterable), आणि Promise.any(iterable) हे प्रॉमिसेसच्या इटरेबलवर कार्य करतात.
• डीस्ट्रक्चरिंग: तुम्ही कोणत्याही इटरेबलसह डीस्ट्रक्चरिंग असाइनमेंट वापरू शकता: const [first, second] = myIterable;
• नवीन APIs: टेक्स्ट सेगमेंटेशनसाठी Intl.Segmenter सारखे आधुनिक APIs देखील इटरेबल ऑब्जेक्ट्स परत करतात.

जेव्हा तुम्ही तुमच्या कस्टम डेटा स्ट्रक्चर्सला इटरेबल बनवता, तेव्हा तुम्ही फक्त `for...of` लूप सक्षम करत नाही; तुम्ही त्यांना या संपूर्ण शक्तिशाली साधनांच्या संचाशी सुसंगत बनवत आहात, ज्यामुळे तुमचा कोड भविष्याशी सुसंगत आणि इतर डेव्हलपर्ससाठी वापरण्यास आणि समजण्यास सोपा होतो.

निष्कर्ष: इटरेशनमधील तुमची पुढील पाऊले

आपण इटरेबल आणि इटररेटर प्रोटोकॉलच्या मूलभूत नियमांपासून स्वतःचे कस्टम इटररेटर तयार करण्यापर्यंत आणि शेवटी जनरेटर फंक्शन्सच्या स्वच्छ, आधुनिक सिंटॅक्सपर्यंत प्रवास केला आहे. आता तुमच्याकडे जावास्क्रिप्टला तुम्ही कल्पना करू शकता अशा कोणत्याही डेटा स्ट्रक्चरमधून कसे जायचे हे शिकवण्याचे ज्ञान आहे.

या प्रोटोकॉलवर प्रभुत्व मिळवणे हे जावास्क्रिप्ट डेव्हलपर म्हणून तुमच्या प्रवासातील एक महत्त्वपूर्ण पाऊल आहे. हे तुम्हाला भाषेच्या वैशिष्ट्यांचे उपभोक्ता होण्यापासून एका निर्मात्याकडे नेते जे भाषेच्या मूळ क्षमतांना तुमच्या विशिष्ट गरजांनुसार विस्तारित करू शकतात.

जागतिक डेव्हलपर्ससाठी कृती करण्यायोग्य अंतर्दृष्टी

• तुमच्या कोडचे ऑडिट करा: तुमच्या सध्याच्या प्रकल्पांमध्ये डेटाचा क्रम दर्शविणाऱ्या ऑब्जेक्ट्स शोधा. तुम्ही त्यांच्यावर .forEachItem() किंवा .getItems() सारख्या कस्टम, अ-मानक मेथड्सने इटरेशन करत आहात का? चांगल्या आंतरकार्यक्षमतेसाठी त्यांना मानक इटररेटर प्रोटोकॉल लागू करण्यासाठी रिफॅक्टर करण्याचा विचार करा.
• आळशीपणाचा स्वीकार करा: मोठे किंवा अगदी अनंत डेटासेट दर्शवण्यासाठी इटररेटर आणि विशेषतः जनरेटर वापरा. यामुळे तुम्हाला मागणीनुसार डेटावर प्रक्रिया करता येते, ज्यामुळे मेमरी कार्यक्षमता आणि कामगिरीमध्ये लक्षणीय सुधारणा होते. तुम्हाला जेवढे आवश्यक आहे, तेव्हाच तुम्ही ते मोजता.
• जनरेटरला प्राधान्य द्या: तुम्ही तयार करत असलेल्या कोणत्याही नवीन ऑब्जेक्टसाठी जो इटरेबल असावा, जनरेटर फंक्शन्स (function*) हा तुमचा डीफॉल्ट पर्याय बनवा. ते अधिक संक्षिप्त, स्टेट मॅनेजमेंटच्या चुकांना कमी प्रवण आणि मॅन्युअल अंमलबजावणीपेक्षा अधिक वाचनीय आहेत.
• क्रमांमध्ये विचार करा: प्रोग्रामिंग समस्यांना क्रमांच्या दृष्टिकोनातून पाहण्यास सुरुवात करा. एक जटिल व्यावसायिक प्रक्रिया, डेटा ट्रान्सफॉर्मेशन पाइपलाइन, किंवा UI स्टेट ट्रान्झिशनला चरणांचा क्रम म्हणून मॉडेल केले जाऊ शकते का? जर हो, तर इटररेटर हे कामासाठी परिपूर्ण, सुंदर साधन असू शकते.

आपल्या डेव्हलपमेंट टूलकिटमध्ये इटररेटर प्रोटोकॉल समाकलित करून, तुम्ही अधिक स्वच्छ, अधिक शक्तिशाली आणि अधिक मुहावरेदार जावास्क्रिप्ट लिहाल जे जगभरातील डेव्हलपर्सद्वारे समजले जाईल आणि त्याचे कौतुक केले जाईल.