```html

Patrones de Diseño en Ruby: Implementando el Iterador

Los patrones de diseño son soluciones reutilizables a problemas comunes en el desarrollo de software. En Ruby, uno de los patrones más útiles y versátiles es el patrón Iterador. Este patrón permite recorrer una colección de objetos sin exponer su representación interna. En este artículo, exploraremos cómo implementar el patrón Iterador en Ruby, sus beneficios y algunos ejemplos prácticos.

¿Qué es un Patrón Iterador?

El patrón Iterador proporciona una forma de acceder a los elementos de una colección de manera secuencial sin tener que conocer la estructura interna de la colección. Esto es especialmente útil cuando se trabaja con estructuras de datos complejas, ya que permite a los desarrolladores interactuar con los elementos de manera más sencilla y limpia.

Ventajas del Patrón Iterador

Encapsulamiento de la colección: Los detalles de la implementación de la colección están ocultos, lo que mejora la modularidad.
Interfaz uniforme: Permite acceder a diferentes colecciones a través de una interfaz común.
Facilidad de mantenimiento: Los cambios en la colección no afectan a los clientes que utilizan el iterador.

Implementación del Patrón Iterador en Ruby

A continuación, veremos cómo implementar el patrón Iterador en Ruby. Crearemos una clase simple que represente una colección de elementos y un iterador que nos permita recorrer esa colección.

Definiendo la Clase Colección

Primero, definiremos una clase que represente nuestra colección de elementos. En este caso, crearemos una clase llamada MiColeccion que almacenará una lista de números.

class MiColeccion
  include Enumerable
  
  def initialize
    @elementos = []
  end

  def agregar(elemento)
    @elementos << elemento
  end

  def each(&bloque)
    @elementos.each(&bloque)
  end
end

En este código, hemos incluido el módulo Enumerable, que proporciona métodos adicionales para trabajar con colecciones. La clase tiene un método agregar que permite añadir elementos a la colección y un método each que itera sobre los elementos y los pasa a un bloque.

Creando el Iterador

Ahora que tenemos nuestra colección, podemos crear un iterador. En Ruby, esto se puede hacer de manera bastante sencilla. Vamos a crear una clase llamada MiIterador que se encargará de recorrer los elementos de MiColeccion.

class MiIterador
  def initialize(coleccion)
    @coleccion = coleccion
    @indice = 0
  end

  def tiene_siguiente?
    @indice < @coleccion.size
  end

  def siguiente
    elemento = @coleccion[@indice]
    @indice += 1
    elemento
  end
end

La clase MiIterador tiene un método tiene_siguiente? que verifica si hay más elementos en la colección y un método siguiente que devuelve el siguiente elemento, avanzando el índice en cada llamada.

Usando el Iterador

Una vez que tenemos nuestra colección y nuestro iterador, podemos usarlos juntos. A continuación, crearemos una instancia de MiColeccion, agregaremos algunos elementos y utilizaremos MiIterador para recorrer esos elementos.

coleccion = MiColeccion.new
coleccion.agregar(1)
coleccion.agregar(2)
coleccion.agregar(3)

iterador = MiIterador.new(coleccion)

while iterador.tiene_siguiente?
  puts iterador.siguiente
end

En este ejemplo, creamos una colección de números del 1 al 3 y utilizamos el iterador para imprimir cada número en la consola. Este enfoque es limpio y mantiene la lógica de iteración separada de la colección misma.

Iteradores en Ruby: Una Aproximación Más Simple

Ruby tiene un enfoque muy flexible para la iteración que se basa en su propio módulo Enumerable. Este módulo proporciona métodos que permiten iterar sobre colecciones de manera muy sencilla. A continuación, veremos cómo podemos usar Enumerable para crear un iterador.

Usando Enumerable

Al incluir Enumerable en nuestra clase de colección, automáticamente tenemos acceso a métodos como map, select, y each_with_index. Esto significa que no siempre necesitamos implementar nuestros propios iteradores. Veamos un ejemplo de cómo usar estos métodos.

class MiColeccion
  include Enumerable
  
  def initialize
    @elementos = []
  end

  def agregar(elemento)
    @elementos << elemento
  end

  def each(&bloque)
    @elementos.each(&bloque)
  end
end

coleccion = MiColeccion.new
coleccion.agregar(1)
coleccion.agregar(2)
coleccion.agregar(3)

# Usando el método map de Enumerable
resultado = coleccion.map { |n| n * 2 }
puts resultado.inspect

En este caso, utilizamos el método map para multiplicar cada elemento de la colección por 2. Esto muestra cómo el módulo Enumerable puede simplificar la iteración y el procesamiento de colecciones en Ruby.

Ejemplo Completo: Implementación de un Iterador Personalizado

Para ilustrar aún más el uso del patrón Iterador, implementaremos un iterador personalizado que permite recorrer una colección de objetos más complejos. Crearemos una clase Libro y una clase Biblioteca que contendrá una colección de libros.

Definiendo la Clase Libro

class Libro
  attr_accessor :titulo, :autor

  def initialize(titulo, autor)
    @titulo = titulo
    @autor = autor
  end
end

La clase Libro tiene dos atributos: titulo y autor. Ahora vamos a implementar la clase Biblioteca.

Definiendo la Clase Biblioteca

class Biblioteca
  include Enumerable
  
  def initialize
    @libros = []
  end

  def agregar_libro(libro)
    @libros << libro
  end

  def each(&bloque)
    @libros.each(&bloque)
  end
end

La clase Biblioteca permite agregar libros y también incluye el método each para iterar sobre ellos. Ahora, implementemos el iterador.

Implementando el Iterador de Biblioteca

class IteradorBiblioteca
  def initialize(biblioteca)
    @biblioteca = biblioteca
    @indice = 0
  end

  def tiene_siguiente?
    @indice < @biblioteca.size
  end

  def siguiente
    libro = @biblioteca[@indice]
    @indice += 1
    libro
  end
end

Ahora que tenemos nuestra clase IteradorBiblioteca, podemos usarla para recorrer los libros en la biblioteca.

Usando el Iterador de Biblioteca

biblioteca = Biblioteca.new
biblioteca.agregar_libro(Libro.new("El Quijote", "Miguel de Cervantes"))
biblioteca.agregar_libro(Libro.new("Cien años de soledad", "Gabriel García Márquez"))
biblioteca.agregar_libro(Libro.new("1984", "George Orwell"))

iterador_biblioteca = IteradorBiblioteca.new(biblioteca)

while iterador_biblioteca.tiene_siguiente?
  libro = iterador_biblioteca.siguiente
  puts "#{libro.titulo} - #{libro.autor}"
end

En este ejemplo, hemos creado una biblioteca que contiene varios libros y hemos utilizado nuestro iterador personalizado para imprimir el título y el autor de cada libro. Este enfoque demuestra la flexibilidad y la potencia del patrón Iterador en Ruby.

Conclusión

El patrón Iterador es una herramienta poderosa en el desarrollo de software, especialmente en Ruby. Permite a los desarrolladores recorrer colecciones de manera eficiente y limpia, manteniendo el código modular y fácil de mantener. A través de los ejemplos presentados, hemos visto cómo implementar un iterador básico y cómo aprovechar el módulo Enumerable para simplificar la iteración en Ruby.

Al aplicar este patrón, no solo mejoramos la legibilidad del código, sino que también facilitamos la extensión y modificación de nuestras colecciones en el futuro. La próxima vez que necesites recorrer una colección, considera usar el patrón Iterador para hacer tu código más limpio y eficiente.

```