Introducció

El patró Iterator és un patró de disseny de comportament que permet recórrer elements d'una col·lecció sense exposar la seva representació subjacent (llista, pila, arbre, etc.). Aquest patró proporciona una manera d'accedir als elements d'un objecte agregat seqüencialment sense exposar la seva estructura subjacent.

Objectius del Patró Iterator

  • Separació de responsabilitats: Permet separar la lògica de recorregut de la col·lecció de la lògica de la col·lecció mateixa.
  • Uniformitat: Proporciona una interfície uniforme per recórrer diferents tipus de col·leccions.
  • Flexibilitat: Facilita l'addició de diferents tipus de recorreguts sense modificar les col·leccions.

Components del Patró Iterator

  1. Iterador (Iterator): Defineix una interfície per accedir i recórrer els elements.
  2. Iterador Concret (Concrete Iterator): Implementa la interfície de l'iterador i manté el seguiment de la posició actual en el recorregut.
  3. Agregat (Aggregate): Declara una interfície per crear un objecte iterador.
  4. Agregat Concret (Concrete Aggregate): Implementa la interfície de l'agregat per retornar una instància de l'iterador concret.

Exemple Pràctic

A continuació, es presenta un exemple pràctic en Python per il·lustrar el patró Iterator.

Definició de la Interfície Iterator

from abc import ABC, abstractmethod

class Iterator(ABC):
    @abstractmethod
    def has_next(self):
        pass
    
    @abstractmethod
    def next(self):
        pass

Implementació de l'Iterador Concret

class ConcreteIterator(Iterator):
    def __init__(self, collection):
        self._collection = collection
        self._index = 0

    def has_next(self):
        return self._index < len(self._collection)

    def next(self):
        if not self.has_next():
            raise StopIteration
        item = self._collection[self._index]
        self._index += 1
        return item

Definició de la Interfície Aggregate

from abc import ABC, abstractmethod

class Aggregate(ABC):
    @abstractmethod
    def create_iterator(self):
        pass

Implementació de l'Agregat Concret

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)

Ús del Patró Iterator

if __name__ == "__main__":
    aggregate = ConcreteAggregate()
    aggregate.add_item("Item 1")
    aggregate.add_item("Item 2")
    aggregate.add_item("Item 3")

    iterator = aggregate.create_iterator()

    while iterator.has_next():
        item = iterator.next()
        print(item)

Exercici Pràctic

Exercici

Implementa el patró Iterator per una col·lecció de números sencers. La col·lecció ha de permetre afegir números i l'iterador ha de recórrer els números en ordre invers.

Solució

class ReverseIterator(Iterator):
    def __init__(self, collection):
        self._collection = collection
        self._index = len(collection) - 1

    def has_next(self):
        return self._index >= 0

    def next(self):
        if not self.has_next():
            raise StopIteration
        item = self._collection[self._index]
        self._index -= 1
        return item

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

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

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

if __name__ == "__main__":
    collection = IntegerCollection()
    collection.add_item(1)
    collection.add_item(2)
    collection.add_item(3)

    iterator = collection.create_iterator()

    while iterator.has_next():
        item = iterator.next()
        print(item)

Conclusió

El patró Iterator és una eina poderosa per recórrer col·leccions de manera uniforme i flexible. Permet separar la lògica de recorregut de la col·lecció, facilitant la implementació de diferents tipus de recorreguts sense modificar la col·lecció subjacent. Aquest patró és àmpliament utilitzat en diverses biblioteques i frameworks per proporcionar una manera consistent d'accedir als elements d'una col·lecció.

© Copyright 2024. Tots els drets reservats