Hvad er Iterator-mønsteret?

Question

Accepted Answer

**Iterator**-mønsteret giver en måde at **gennemløbe en samling** sekventielt uden at eksponere dens interne struktur. Det er så grundlæggende, at det er indbygget i de fleste moderne sprog (for-of-løkker, iteratorer, generatorer).

## Hvad Iterator-mønsteret gør

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

## Indbygget i moderne sprog

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

## Fordele og anvendelser

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

## Hvorfor det betyder noget

At forstå Iterator-mønsteret er værdifuldt, fordi det er et **grundlæggende mønster, der er indbygget i de fleste moderne sprog**, så at genkende det uddyber forståelsen af hverdagens sprogtræk.

Iterator-mønsteret giver sekventiel gennemløbelse af en samling uden at eksponere dens interne struktur — og det er så grundlæggende, at det er **indbygget i de fleste moderne sprog** (for-of-løkker, iteratorer, generatorer).

At forstå, hvad det gør (at give standard sekventiel gennemløbelse samtidig med at skjule samlingens interne struktur, afkobling af gennemløbelse fra samlingen), er kernekendskabet.

At forstå, at det er **indbygget i sprog**, er den vigtigste praktiske indsigt: for-of-løkken (JavaScript), iteratorer, generatorer, IEnumerable (C#) og Iterator (Java) er alle Iterator-mønsteret — så at genkende dette uddyber forståelsen af disse hverdagslige sprogtræk, du bruger konstant, og afslører, at velkendt iteration er en instans af et klassisk mønster.

At forstå **fordelene** — **ensartet gennemløbelse** (gennemløb af enhver samling på samme måde uanset interne struktur), **indkapsling** (at holde internals skjult) og især **lazy iteration** (generatorer, der beregner elementer on demand) — og **anvendelserne** — gennemløbelse af samlinger, **lazy sequences** (behandling af enorme eller uendelige sekvenser uden at indlæse alt på én gang, en kraftfuld evne), brugerdefinerede iterable-objekter og pipelines (map/filter over iteratorer) — præciserer dens praktiske værdi.

Den lazy-iteration-evne (generatorer) er særligt værdifuld for effektivitet med store data.

At genkende Iterator-mønsteret i sprogtræk (for-of, generatorer) er et godt eksempel på mønstre, der bliver optaget i sprog, som forbinder mønsterteori med hverdagskode.

Da Iterator-mønsteret er grundlæggende og indbygget i de fleste moderne sprog (for-of, iteratorer, generatorer), og da genkendelse af det uddyber forståelsen af disse hverdagslige træk og den værdifulde lazy-sequence-evne, og da forståelsen af det forbinder mønsterteori med konstant brugt kode, er forståelse af Iterator-mønsteret værdifuld, praktisk relevant designviden — et grundlæggende mønster, der er indbygget i moderne sprog (for-of, generatorer), hvis genkendelse uddyber forståelsen af hverdags iteration, med værdifulde lazy-sequence-evner, og et godt eksempel på mønstre, der er optaget i sprogtræk.