Iterator pattern என்றால் என்ன?

Question

Accepted Answer

**Iterator** pattern ஒரு collection-ஐ **வரிசையாக traverse செய்வதற்கான** வழிமுறையை வழங்குகிறது, அதன் internal structure-ஐ expose செய்யாமல். இது மிகவும் அடிப்படையான pattern ஆகும், பெரும்பாலான நவீன languages-ல் (for-of loops, iterators, generators) built-in ஆக இருக்கிறது.

## 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
```

## Benefits மற்றும் uses

```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 sequential traversal ஐ ஒரு collection-இன் internal structure-ஐ expose செய்யாமல் வழங்குகிறது — மேலும் இது மிகவும் அடிப்படையான pattern ஆகும், அது **பெரும்பாலான நவீன languages-ல் built-in** ஆக உள்ளது (for-of loops, iterators, generators).

இது என்ன செய்கிறது என்பதை புரிந்துகொள்வது (standard sequential traversal-ஐ வழங்குவது, collection-இன் internal structure-ஐ hiding செய்வது, traversal-ஐ collection-இலிருந்து decouple செய்வது) என்பது மূல அறிவு ஆகும்.

**Languages-ல் built-in** என்பதை புரிந்துகொள்வது முக்கிய practical insight ஆகும்: for-of loop (JavaScript), iterators, generators, IEnumerable (C#), மற்றும் Iterator (Java) அனைத்தும் Iterator pattern-இன் வெளிப்பாடுகள் — எனவே இதை அறிந்திருப்பது உங்கள் நாளாந்த iteration features-ஐ புரிந்துகொள்வதை ஆழப்படுத்துகிறது, இது நீங்கள் தொடர்ந்து பயன்படுத்தும் familiar iteration ஒரு classic pattern-இன் instance என்பதை வெளிப்படுத்துகிறது.

**Benefits** — **uniform traversal** (எந்த collection-ஐயும் internal structure-ஐ பொருட்படுத்தாமல் ஒரே வழிமுறையில் iterate செய்வது), **encapsulation** (internals-ஐ hidden வைத்திருப்பது), மற்றும் குறிப்பாக **lazy iteration** (generators demand-ல் elements-ஐ compute செய்வது) — மற்றும் **uses** — collections-ஐ traverse செய்வது, **lazy sequences** (பெரிய அல்லது infinite sequences-ஐ எல்லாவற்றையும் load செய்யாமல் process செய்வது, ஒரு சக்திशালী capability), custom iterables, மற்றும் pipelines (map/filter over iterators) — புரிந்துகொள்வது அதன் practical value-ஐ தெளிவுபடுத்துகிறது.

Lazy-iteration capability (generators) என்பது பெரிய data-க்கு efficiency-க்கு குறிப்பாக மதிப்புமிக்கது.

Language features-ல் (for-of, generators) Iterator pattern-ஐ அடையாளம் காண்பது, patterns languages-ஆக absorption செய்யப்படுவதற்கான நல்ல உதாரணம், pattern theory-ஐ everyday code-க்குடன் இணைக்கிறது.

Iterator pattern அடிப்படையான pattern ஆகும், பெரும்பாலான நவீன languages-ல் built-in ஆக இருக்கிறது (for-of, iterators, generators), மேலும் இதை அறிந்திருப்பது நாளாந்த iteration features-ஐ ஆழப்படுத்துகிறது, மதிப்புமிக்க lazy-sequence capabilities-உடன், மற்றும் languages-ல் absorbed patterns-இன் நல்ல உதாரணம், எனவே Iterator pattern-ஐ புரிந்துகொள்வது மதிப்புமிக்கது, practically-relevant design knowledge — ஒரு அடிப்படையான pattern built-in நவீன languages-ல் (for-of, generators), இதை அறிந்திருப்பது everyday iteration-இன் புரிந்துகொள்வதை ஆழப்படுத்துகிறது, மதிப்புமிக்க lazy-sequence capabilities-உடன், மற்றும் constantly-used code-க்குடன் pattern theory-ஐ இணைக்கும் நல்ல உதாரணம்.