Iterator Pattern

Definition

The Iterator Pattern is a design pattern that provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. This pattern is particularly useful when dealing with collections of objects, allowing you to traverse through them without needing to understand their internal structure.

Structure

The Iterator Pattern typically involves the following components:

• Iterator: An interface that defines methods for traversing the collection.
• Concrete Iterator: Implements the Iterator interface and keeps track of the current position in the traversal.
• Aggregate: An interface that defines a method for creating an iterator.
• Concrete Aggregate: Implements the Aggregate interface and returns an instance of a Concrete Iterator.

Implementation

Here is a simple implementation in Python:

class Iterator:
    def __next__(self):
        pass

class ConcreteIterator(Iterator):
    def __init__(self, aggregate):
        self._aggregate = aggregate
        self._index = 0

    def __next__(self):
        if self._index < len(self._aggregate):
            result = self._aggregate[self._index]
            self._index += 1
            return result
        raise StopIteration

class Aggregate:
    def create_iterator(self):
        pass

class ConcreteAggregate(Aggregate):
    def __init__(self):
        self._items = []

    def add_item(self, item):
        self._items.append(item)

    def create_iterator(self):
        return ConcreteIterator(self._items)

# Usage
aggregate = ConcreteAggregate()
aggregate.add_item("Item 1")
aggregate.add_item("Item 2")

iterator = aggregate.create_iterator()
for item in iterator:
    print(item)
                

Best Practices

When implementing the Iterator Pattern, consider the following best practices:

1. Keep the Iterator and Aggregate interfaces separate to ensure flexibility.
2. Make sure the Iterator does not expose the internal structure of the Aggregate.
3. Consider using multiple Iterators for the same Aggregate if needed.

FAQ