This lesson follows Command. It also builds on the tree in Composite.

Iterator moves traversal logic and progress into a separate object. A client asks for the next element without knowing storage details. The cost is iterator state and a contract for changes during traversal.

Hide traversal details, not ordering

A menu tree has root A, children B and C, and grandchild D under B. A search screen wants each node. Depth-first traversal yields A, B, D, C. Breadth-first traversal yields A, B, C, D. Both visit the same nodes. Their order differs.

type TreeNode = { name: string; children: TreeNode[] };
function* depthFirst(root: TreeNode): Generator<TreeNode> {
  const stack = [root];
  while (stack.length > 0) {
    const current = stack.pop()!;
    yield current;
    for (let i = current.children.length - 1; i >= 0; i--) {
      stack.push(current.children[i]!);
    }
  }
}

const tree: TreeNode = {
  name: "A", children: [
    { name: "B", children: [{ name: "D", children: [] }] },
    { name: "C", children: [] },
  ],
};
const first = depthFirst(tree);
const second = depthFirst(tree);
first.next().value?.name;  // A
first.next().value?.name;  // B
second.next().value?.name; // A
for (const node of depthFirst(tree)) console.log(node.name);

A JavaScript generator provides the iterator protocol. Calling the generator function creates a fresh iterator. Each owns its own stack. A collection wrapper can return these through Symbol.iterator or named traversal methods.

Keep progress per iterator

Use the language's traversal contract first

Most modern languages build the pattern in. JavaScript has the iterator protocol, Symbol.iterator, and generators. Java has Iterator and Iterable. Python has __iter__ and __next__. Use built-in iterators for ordinary arrays. A separate abstraction earns its cost when storage is complex, traversal is reused, or data arrives incrementally.

Map the roles

Role	In this example	Job
Iterator	the protocol: next() returning { value, done }	Declares the operations needed to traverse a collection: fetch the next element, and sometimes get the current position or restart
Concrete iterators	the depthFirst generator with its private stack	Implement one traversal algorithm and track their own progress, so several iterators can walk one collection independently
Collection	a wrapper that exposes [Symbol.iterator]() or depthFirst()	Declares methods that return iterators. Their return type is the iterator interface, so concrete collections can return different kinds of iterators.
Concrete collections	the menu tree	Return a new concrete iterator each time a client asks
Client	a for...of loop	Works with collections and iterators through their interfaces, so the same code handles many collections and traversals. Usually gets iterators from the collection rather than creating them.

Reach for it when traversal should not leak structure

• your collection has a complex data structure that you want to hide from clients, for convenience or for safety. Clients get a few simple methods, and they cannot corrupt the collection by poking at its internals.
• you want to cut duplicated traversal code across your app. Non-trivial traversal code is often bulky. Inside business logic, it blurs the original code's responsibility.
• your code must traverse different data structures, or structures whose types are unknown in advance. Code that depends only on the collection and iterator interfaces still works when you pass it new kinds of collections and iterators.

Implement it in five steps

Refactor existing code toward the pattern in this order:

1. Declare the iterator interface. At minimum it fetches the next element. For convenience, add methods such as fetching the previous element, tracking the current position, or checking for the end.
2. Declare the collection interface with a method for fetching iterators. Its return type must be the iterator interface. Declare several such methods if you plan several groups of iterators.
3. Implement concrete iterator classes for the collections you want to traverse. Link each iterator object to one collection instance, usually through the iterator's constructor.
4. Implement the collection interface in your collection classes. Their methods give clients a shortcut to the right iterator, and the collection passes itself to the iterator's constructor.
5. Replace the traversal code in the client with iterators. The client fetches a new iterator every time it needs to walk the collection.

Name what it costs

You gain	You pay
Bulky traversal algorithms move into their own classes (single responsibility)	Overkill if your app only works with simple collections
New collections and iterators work with existing code (open/closed)	Going through an iterator can be slower than walking some specialized collections directly
The same collection can be traversed in parallel, because each iterator has its own state	Ordering, mutation, and cycle behavior still need documentation
A traversal can pause and resume when needed	Every iterator stores its own progress

Do not confuse it with its neighbors

Pattern	How it relates
Composite	Use iterators to traverse composite trees.
Factory Method	Collection subclasses can use a factory method to return the iterator type that matches them.
Memento	Combine them to capture the current iteration state and roll back to it if needed.
Visitor	Combine them to traverse a complex structure and run an operation on its elements, even when the elements belong to different classes. Iterator supplies the traversal, and Visitor supplies the operation.

Retrieve and apply

Predict the first four elements from depth-first and breadth-first traversal before selecting each option. Continue to Mediator to centralize cooperation among components.