Iterator pattern क्या है?

Question

Accepted Answer

**Iterator** pattern किसी collection को उसकी internal structure को उजागर किए बिना **क्रमिक रूप से traverse करने** का तरीका प्रदान करता है। यह इतना मूलभूत है कि यह अधिकांश आधुनिक languages में built-in है (for-of loops, iterators, generators)।

## Iterator pattern क्या करता है

```text
ITERATOR → access elements of a collection SEQUENTIALLY without exposing its internals:
  → provides a standard way to traverse (next element, has more?)
  → the collection's internal structure (array, tree, linked list) is HIDDEN
  → decouples traversal logic from the collection
→ "iterate without caring how the collection is structured"
```

## आधुनिक languages में built-in

```js
// most languages have the Iterator pattern built in
for (const item of collection) { /* ... */ }   // works for arrays, sets, maps, custom iterables

// custom iterables/generators implement the iterator protocol
function* range(n) { for (let i = 0; i < n; i++) yield i; }   // a generator (iterator)
for (const i of range(5)) console.log(i);   // 0,1,2,3,4
```

```text
→ for-of (JS), for-in (Python), iterators, generators, IEnumerable (C#), Iterator (Java)
  → all are the Iterator pattern, built into the language
```

## फायदे और उपयोग

```text
BENEFITS:
  ✓ UNIFORM traversal → iterate any collection the same way (regardless of internal structure)
  ✓ ENCAPSULATION → the collection's internals stay hidden
  ✓ Multiple iterators; lazy iteration (generators → compute elements on demand)
USES → traversing any collection; LAZY sequences (process huge/infinite sequences without
  loading all at once); custom iterables; pipelines (map/filter over iterators)
```

## यह क्यों महत्वपूर्ण है

Iterator pattern को समझना मूल्यवान है क्योंकि यह एक **अधिकांश आधुनिक languages में built-in मूलभूत pattern** है, इसलिए इसे पहचानना रोज़मर्रा की language features की समझ को गहरा करता है।

Iterator pattern किसी collection को उसकी internal structure को उजागर किए बिना क्रमिक traversal प्रदान करता है — और यह इतना मूलभूत है कि यह **अधिकांश आधुनिक languages में built-in** है (for-of loops, iterators, generators)।

यह क्या करता है यह समझना (standard क्रमिक traversal प्रदान करते हुए collection की internal structure को छिपाना, traversal को collection से decouple करना) मूल ज्ञान है।

यह समझना कि यह **languages में built-in** है अहम व्यावहारिक अंतर्दृष्टि है: for-of loop (JavaScript), iterators, generators, IEnumerable (C#), और Iterator (Java) सभी Iterator pattern हैं — इसलिए इसे पहचानना इन रोज़मर्रा की language features की समझ को गहरा करता है जिनका आप लगातार इस्तेमाल करते हैं, यह प्रकट करते हुए कि परिचित iteration एक classic pattern का उदाहरण है।

**फायदों** को समझना — **uniform traversal** (किसी भी collection को internal structure की परवाह किए बिना एक ही तरह से iterate करना), **encapsulation** (internals को छिपा रखना), और खासकर **lazy iteration** (generators elements को on demand compute करते हुए) — और **उपयोगों** को — collections को traverse करना, **lazy sequences** (huge या infinite sequences को सब कुछ एक साथ load किए बिना process करना, एक शक्तिशाली क्षमता), custom iterables, और pipelines (iterators पर map/filter) — इसके व्यावहारिक मूल्य को स्पष्ट करता है।

lazy-iteration क्षमता (generators) विशेष रूप से बड़े data के साथ efficiency के लिए मूल्यवान है।

language features (for-of, generators) में Iterator pattern को पहचानना patterns के languages में समाहित होने का एक अच्छा उदाहरण है, pattern theory को रोज़मर्रा के code से जोड़ता है।

चूँकि Iterator pattern मूलभूत है और अधिकांश आधुनिक languages में built-in है (for-of, iterators, generators), और चूँकि इसे पहचानना इन रोज़मर्रा की features और मूल्यवान lazy-iteration क्षमता की समझ को गहरा करता है, और चूँकि इसे समझना pattern theory को लगातार इस्तेमाल होने वाले code से जोड़ता है, इसलिए Iterator pattern को समझना मूल्यवान, व्यावहारिक रूप से प्रासंगिक design ज्ञान है — आधुनिक languages में built-in एक मूलभूत pattern (for-of, generators), जिसे पहचानना रोज़मर्रा के iteration की समझ को गहरा करता है, मूल्यवान lazy-sequence क्षमताओं के साथ, और patterns के language features में समाहित होने का एक अच्छा उदाहरण।