Design Patterns in Go
  • Portada
  • Introducción
  • Publicación
  • Parte I
    • Sobre Go
    • POO en Go
      • Objetos
      • Herencia / Composición
      • S.O.L.I.D
  • Parte II
    • Patrones de Diseño
      • GoF
      • Patrones de Comportamiento
        • Strategy
        • Chain of Responsibility
        • Command
        • Template Method
        • Memento
        • Interpreter
        • Iterator
        • Visitor
        • State
        • Mediator
        • Observer
      • Patrones Creacionales
        • Singleton
        • Builder
        • Factory Method
        • Abstract Factory
        • Prototype
      • Patrones Estructurales
        • Composite
        • Adapter
        • Bridge
        • Proxy
        • Decorator
        • Facade
        • Flyweight
  • Parte III
    • Conclusiones
    • Acerca De
  • Recursos de interés
  • Glosario
Con tecnología de GitBook
En esta página
  • Propósito
  • También conocido como
  • Estructura
  • Participantes
  • Implementación
  • Código de ejemplo

¿Te fue útil?

  1. Parte II
  2. Patrones de Diseño
  3. Patrones de Comportamiento

Iterator

AnteriorInterpreterSiguienteVisitor

Última actualización hace 5 años

¿Te fue útil?

Propósito

Según el libro "Patrones de Diseño" el patrón Iterator "proporciona un modo de acceder secuencialmente a los elementos de un objeto agregado sin exponer su representación interna".

También conocido como

Cursor

Estructura

Participantes

  • Iterador:

    • define una interfaz para recorrer los elementos y acceder a ellos.

  • IteradorConcreto:

    • implementa la interfaz Iterador.

    • mantiene la posición actual en el recorrido del agregado.

  • Agregado:

    • define una interfaz para crear una variable Iterador.

  • AgregadoConcreto:

    • implementa la interfaz de creación de Iterador para devolver una variable del IteradorConcreto apropiado.

Implementación

  • No se observan impedimentos y/o modificaciones de la estructura original del patrón para su implementación en Go.

  • El Iterador y Agregado se definen como interfaces por simplificación.

Código de ejemplo

En este ejemplo queremos recorrer las distintas estaciones de radio preseteadas de un estéreo de audio.

Implementación:

// Iterador Interface
type Iterador interface {
    Valor() string
    Siguiente()
    Anterior()
}

// Agregado Interface
type Agregado interface {
    CrearIterador() Iterador
}

// Agregado Concreto
type Radio struct {
    Estaciones []string
}

func (r *Radio) CrearIterador() Iterador {
    return &RadioIterador{radio: r}
}

func (r *Radio) Registrar(estacion string) {
    r.Estaciones = append(r.Estaciones, estacion)
}

// Iterador Concreto
type RadioIterador struct {
    radio  *Radio
    indice int
}

func (ri *RadioIterador) Valor() string {
    return ri.radio.Estaciones[ri.indice]
}

func (ri *RadioIterador) Siguiente() {
    ri.indice++
}

func (ri *RadioIterador) Anterior() {
    ri.indice--
}

Se puede probar la implementación del patrón de la siguiente forma:

radio := &Radio{}
radio.Registrar("FM100")
radio.Registrar("FM200")
radio.Registrar("FM300")

iterador := radio.CrearIterador()

fmt.Printf("Escuhando la radio %s\n", iterador.Valor())

iterador.Siguiente()
fmt.Printf("Escuhando la radio %s\n", iterador.Valor())

iterador.Siguiente()
fmt.Printf("Escuhando la radio %s\n", iterador.Valor())

iterador.Anterior()
fmt.Printf("Escuhando nuevamente la radio %s\n", iterador.Valor())

|

Atención: Esta publicación se encuentra abandonada. Puede acceder a la versión vigente en

Código de ejemplo
Ejecutar código
https://leanpub.com/designpatternsingo
[29]