Mis apuntes · Aprende Go desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 22 de 36 · Errores y funciones ✦ WebMCP implementado

Iteradores: el yield de PHP en Go

9 min de lectura 5 retos

En PHP, una función con yield es un generator: va entregando valores de uno en uno a tu foreach, sin montar el array entero. Go hace lo mismo con funciones que puedes recorrer con range y el paquete iter.

¿De dónde vienen los nombres?

iter = iterator (iterador)
El paquete con los tipos de los iteradores. Un iterador es algo que va dando valores de uno en uno: lo que en PHP es un Iterator o un Generator.
Seq = Sequence (secuencia)
iter.Seq[V] es una secuencia de valores de tipo V: tu Generator que hace yield $valor.
Seq2 = Sequence de 2 valores
Da los valores por parejas, clave y valor: el yield $clave => $valor de PHP.
yield = to yield (entregar, ceder)
La misma palabra que en PHP. En Go no es una palabra clave: es el nombre de costumbre de la función que recibe cada valor.
En 4 ideas
1/4

Un iterador de Go es una función que recibe otra, yield, y la llama una vez por cada valor. Su tipo es iter.Seq[Tarea]. En PHP es una función con yield que devuelve un Generator.

1 · De los generators de PHP a Go

Imagina una lista de 100 000 tareas. Si la filtras con array_filter, PHP monta un array nuevo enorme antes de que puedas usar la primera. Un generator es una cinta transportadora de sushi: los platos salen de uno en uno, coges el que quieres y, si ya estás lleno, te levantas sin que preparen el resto.

PHP 8.5pendientes.php
<?php
declare(strict_types=1);

final readonly class Tarea
{
    public function __construct(
        public string $titulo,
        public bool $hecha = false,
    ) {}
}

/** @return Generator<int, Tarea> */
function pendientes(array $tareas): Generator
{
    foreach ($tareas as $tarea) {
        if (!$tarea->hecha) {
            yield $tarea;
        }
    }
}

$tareas = [
    new Tarea('Comprar pan'),
    new Tarea('Repasar Go', true),
    new Tarea('Llamar al banco'),
];

foreach (pendientes($tareas) as $tarea) {
    echo "Pendiente: {$tarea->titulo}" . PHP_EOL;
}
Gomain.go
package main

import (
    "fmt"
    "iter"
)

type Tarea struct {
    Titulo string
    Hecha  bool
}

// Pendientes devuelve un iterador: no monta ningún slice nuevo.
func Pendientes(ts []Tarea) iter.Seq[Tarea] {
    return func(yield func(Tarea) bool) {
        for _, t := range ts {
            if t.Hecha {
                continue
            }
            // En PHP: yield $tarea;
            if !yield(t) {
                return
            }
        }
    }
}

func main() {
    ts := []Tarea{
        {Titulo: "Comprar pan"},
        {Titulo: "Repasar Go", Hecha: true},
        {Titulo: "Llamar al banco"},
    }

    // En PHP: foreach (pendientes($tareas) as $tarea)
    for t := range Pendientes(ts) {
        fmt.Println("Pendiente:", t.Titulo)
    }
}

Se parecen mucho. Las diferencias están en cómo se escribe el iterador: en Go devuelves una función que recibe yield, y cada yield(t) te contesta si el bucle quiere más.

2 · iter.Seq: una función que llama a tu bucle

iter.Seq[V] no es nada mágico. Es solo un nombre para este tipo de función:

Gomain.go
// En el paquete iter de la biblioteca estándar:
type Seq[V any] func(yield func(V) bool)

Cuando escribes for t := range seq { … }, Go convierte el cuerpo de tu bucle en la función yield y se la pasa al iterador. Cada vez que el iterador llama a yield(t), se ejecuta una vuelta de tu bucle. Míralo con prints: el iterador y el bucle se van turnando.

Gomain.go
package main

import (
    "fmt"
    "iter"
)

// Numerar da los números de desde a hasta, sin crear ningún slice.
// En PHP: function numerar(int $desde, int $hasta): Generator
func Numerar(desde, hasta int) iter.Seq[int] {
    return func(yield func(int) bool) {
        for i := desde; i <= hasta; i++ {
            fmt.Println("  el iterador entrega", i)
            if !yield(i) {
                return
            }
        }
    }
}

func main() {
    for n := range Numerar(1, 3) {
        fmt.Println("el bucle usa la tarea", n)
    }
}

3 · yield devuelve bool: el break del bucle

¿Qué pasa si el bucle hace break a mitad? En PHP el generator se queda parado y, si nadie vuelve a pedirle valores, se olvida. En Go, yield te avisa: devuelve false, y tu iterador debe dejar de entregar con return.

Gomain.go
package main

import (
    "fmt"
    "iter"
)

func Titulos(ts []string) iter.Seq[string] {
    return func(yield func(string) bool) {
        for _, t := range ts {
            if !yield(t) {
                fmt.Println("  yield devolvió false: paro aquí")
                return
            }
        }
        fmt.Println("  no quedan más")
    }
}

func main() {
    ts := []string{"Comprar pan", "Pagar el alquiler", "Repasar Go"}

    for t := range Titulos(ts) {
        fmt.Println("Hoy toca:", t)
        if t == "Pagar el alquiler" {
            break
        }
    }
    fmt.Println("Fin del día")
}

Si te olvidas del if !yield(…) y sigues llamando a yield después de un break, el programa se para con este panic (salida real):

panic: runtime error: range function continued iteration after function for loop body returned false

¿Por qué? · En PHP no existe

¿Por qué yield devuelve un bool? En PHP no devuelve nada

En PHP el generator es una función en pausa: PHP guarda su estado y la despierta cada vez que el foreach pide otro valor. Si el foreach hace break, el generator se queda dormido y nadie le avisa. Si tenía un fichero abierto, se cerrará cuando PHP lo recoja, no cuando tú quieras.

Go no pausa funciones: el iterador corre de verdad y llama a tu bucle. Por eso necesita una forma de enterarse de que el bucle ya no quiere más, y esa forma es el bool que devuelve yield:

  • El iterador para en el momento del break, no cuando alguien se acuerde.
  • Sus defer se ejecutan en ese momento: si abrió algo, lo cierra a tiempo.
  • Y si un iterador mal escrito sigue entregando, Go lo detecta con el panic de arriba en vez de dejarlo pasar.

4 · iter.Seq2: parejas clave y valor

Cuando quieres entregar dos cosas a la vez, como la posición y la tarea o el ID y el título, usas iter.Seq2[K, V]. Su yield recibe dos valores. Es el yield $clave => $valor de PHP, y se recorre con for k, v := range.

Gomain.go
package main

import (
    "fmt"
    "iter"
    "maps"
    "slices"
)

type Tarea struct {
    ID     int
    Titulo string
}

// PorID entrega cada tarea con su ID como clave.
// En PHP: yield $tarea->id => $tarea;
func PorID(ts []Tarea) iter.Seq2[int, Tarea] {
    return func(yield func(int, Tarea) bool) {
        for _, t := range ts {
            if !yield(t.ID, t) {
                return
            }
        }
    }
}

func main() {
    ts := []Tarea{{ID: 10, Titulo: "Comprar pan"}, {ID: 20, Titulo: "Repasar Go"}}

    for id, t := range PorID(ts) {
        fmt.Println(id, "=>", t.Titulo)
    }

    // slices.All ya viene hecho: da (posición, valor)
    // En PHP: foreach ($tareas as $i => $tarea)
    for i, t := range slices.All(ts) {
        fmt.Println("posición", i, "=>", t.Titulo)
    }

    // maps.Collect convierte un Seq2 en un map
    // En PHP: array_column($tareas, null, 'id')
    porID := maps.Collect(PorID(ts))
    fmt.Println(porID[20].Titulo)
}

5 · slices.Collect y los iteradores de serie

Un iterador no es un slice: no puedes hacer len() ni [0]. Cuando necesites la lista entera, la recoges con slices.Collect, el iterator_to_array() de PHP. Y los paquetes slices y maps traen iteradores ya hechos para no escribirlos tú:

FunciónQué daEn PHP
slices.Values(ts)Los valores del slice (iter.Seq)foreach ($ts as $t)
slices.All(ts)Posición y valor (iter.Seq2)foreach ($ts as $i => $t)
maps.Keys(m)Las claves del map, sin orden fijoarray_keys($m)
slices.Collect(seq)Un slice con todo lo del iteradoriterator_to_array($gen, false)
slices.Sorted(seq)Un slice ordenado con todo lo del iteradoriterator_to_array() + sort()
Gomain.go
package main

import (
    "fmt"
    "maps"
    "slices"
)

func main() {
    // Cuántas tareas hay de cada etiqueta
    porEtiqueta := map[string]int{"casa": 3, "trabajo": 5, "go": 2}

    // En PHP: $etiquetas = array_keys($porEtiqueta); sort($etiquetas);
    etiquetas := slices.Sorted(maps.Keys(porEtiqueta))
    fmt.Println(etiquetas)

    titulos := []string{"Comprar pan", "Repasar Go"}
    copia := slices.Collect(slices.Values(titulos))
    fmt.Println(copia, len(copia))
}

Equivalencia POO · PHP → Go

En PHP, para que un objeto se pueda recorrer con foreach, implementas Iterator o IteratorAggregate. En Go basta con un método que devuelva un iter.Seq.

PHPGoQué cambia
function f(): Generator { yield $t; }func F() iter.Seq[Tarea] que llama a yield(t)El iterador es una función que recibe yield
yield $id => $tarea;iter.Seq2[int, Tarea] y yield(id, t)Dos valores en vez de clave => valor
class Lista implements IteratorAggregatemétodo func (l Lista) All() iter.Seq[Tarea]Sin implements: un método y listo; se recorre con range l.All()
implements Iterator (current, next, valid…)iter.Pull(seq)Si de verdad necesitas pedir los valores a mano, de uno en uno
yield from otro();for v := range otro() { if !yield(v) { return } }No hay atajo: se recorre y se reentrega
iterator_to_array($gen, false)slices.Collect(seq)Monta el slice entero
$gen->send($valor)—No existe: los iteradores de Go solo entregan

Hora de practicar

Retos · 0/5 resueltos

Reto 1 de 5

Un range() perezoso

Completa Rango(desde, hasta int) iter.Seq[int] para que entregue todos los números de desde a hasta, ambos incluidos, sin crear ningún slice. Es el range() de PHP, pero perezoso, como un generator. Si desde > hasta, no entrega nada.

Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.

Gomain.go · editable

Resumen

Lo que te llevas de esta lección

  1. Un iterador es iter.Seq[T]: una función que recibe yield (en PHP, una función con yield que devuelve Generator).
  2. Se recorre con for t := range seq (en PHP, foreach ($gen as $t)).
  3. if !yield(t) { return }: cuando el bucle hace break, el iterador para (en PHP, el generator se queda dormido).
  4. iter.Seq2[K, V] entrega parejas (en PHP, yield $k => $v).
  5. slices.Collect, slices.Values, slices.Sorted(maps.Keys(m)) vienen de serie (en PHP, iterator_to_array, array_keys + sort).

Para recordarlo: «Si yield dice no, return»

Cada yield(t) es una pregunta: «¿quieres otra?». Si contesta false, el bucle hizo break y tu iterador sale con return. Escríbelo siempre igual: if !yield(t) { return }.