O que é o padrão Iterator?

Question

Accepted Answer

O padrão **Iterator** fornece uma maneira de **percorrer uma coleção** sequencialmente sem expor sua estrutura interna. É tão fundamental que está integrado na maioria das linguagens modernas (loops for-of, iteradores, geradores).

## O que o padrão Iterator faz

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

## Integrado em linguagens modernas

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

## Benefícios e usos

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

## Por que isso importa

Entender o padrão Iterator é valioso porque é um **padrão fundamental integrado na maioria das linguagens modernas**, então reconhecê-lo aprofunda a compreensão dos recursos de linguagem cotidianos.

O padrão Iterator fornece travessia sequencial de uma coleção sem expor sua estrutura interna — e é tão fundamental que está **integrado na maioria das linguagens modernas** (loops for-of, iteradores, geradores).

Entender o que ele faz (fornecendo travessia sequencial padrão enquanto oculta a estrutura interna da coleção, desacoplando a travessia da coleção) é o conhecimento central.

Entender que ele está **integrado em linguagens** é a percepção prática fundamental: o loop for-of (JavaScript), iteradores, geradores, IEnumerable (C#) e Iterator (Java) são todos o padrão Iterator — então reconhecer isso aprofunda a compreensão desses recursos de linguagem cotidianos que você usa constantemente, revelando que a iteração familiar é uma instância de um padrão clássico.

Entender os **benefícios** — **travessia uniforme** (iterar qualquer coleção da mesma forma independentemente da estrutura interna), **encapsulamento** (mantendo os internals ocultos) e especialmente **iteração preguiçosa** (geradores computando elementos sob demanda) — e os **usos** — percorrendo coleções, **sequências preguiçosas** (processando sequências enormes ou infinitas sem carregar tudo de uma vez, uma capacidade poderosa), iteráveis personalizados e pipelines (map/filter sobre iteradores) — esclarece seu valor prático.

A capacidade de iteração preguiçosa (geradores) é particularmente valiosa para eficiência com dados grandes.

Reconhecer o padrão Iterator em recursos de linguagem (for-of, geradores) é um bom exemplo de padrões sendo absorvidos em linguagens, conectando teoria de padrões ao código cotidiano.

Já que o padrão Iterator é fundamental e integrado na maioria das linguagens modernas (for-of, iteradores, geradores), e já que reconhecê-lo aprofunda a compreensão desses recursos cotidianos e a capacidade valiosa de iteração preguiçosa, e já que entendê-lo conecta teoria de padrões ao código constantemente utilizado, entender o padrão Iterator é conhecimento de design valioso e praticamente relevante — um padrão fundamental integrado em linguagens modernas (for-of, geradores), cujo reconhecimento aprofunda a compreensão da iteração cotidiana, com capacidades valiosas de sequências preguiçosas, e um bom exemplo de padrões absorvidos em recursos de linguagem.