Lección 22 de 36 · Errores y funciones✦ WebMCP implementado
Iteradores: el yield de PHP en Go
9 min de lectura5 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.
Se recorre con el range de siempre: for t := range Pendientes(ts). Es el foreach (pendientes($tareas) as $tarea) de PHP.
yield devuelve un bool: false significa «el bucle hizo break, para ya». El iterador tiene que hacer return entonces. En PHP el generator simplemente se queda parado y no te enteras.
Para parejas clave-valor se usa iter.Seq2[K, V], como yield $id => $tarea, y slices.Collect convierte un iterador en un slice: el iterator_to_array() de PHP.
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.
package main
import (
"fmt""iter"
)
typeTareastruct {
TitulostringHechabool
}
// Pendientes devuelve un iterador: no monta ningún slice nuevo.funcPendientes(ts []Tarea) iter.Seq[Tarea] {
returnfunc(yield func(Tarea) bool) {
for _, t := range ts {
if t.Hecha {
continue
}
// En PHP: yield $tarea;if !yield(t) {
return
}
}
}
}
funcmain() {
ts := []Tarea{
{Titulo: "Comprar pan"},
{Titulo: "Repasar Go", Hecha: true},
{Titulo: "Llamar al banco"},
}
// En PHP: foreach (pendientes($tareas) as $tarea)for t := rangePendientes(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:typeSeq[Vany] 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): GeneratorfuncNumerar(desde, hasta int) iter.Seq[int] {
returnfunc(yield func(int) bool) {
for i := desde; i <= hasta; i++ {
fmt.Println(" el iterador entrega", i)
if !yield(i) {
return
}
}
}
}
funcmain() {
for n := rangeNumerar(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"
)
funcTitulos(ts []string) iter.Seq[string] {
returnfunc(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")
}
}
funcmain() {
ts := []string{"Comprar pan", "Pagar el alquiler", "Repasar Go"}
for t := rangeTitulos(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"
)
typeTareastruct {
IDintTitulostring
}
// PorID entrega cada tarea con su ID como clave.// En PHP: yield $tarea->id => $tarea;funcPorID(ts []Tarea) iter.Seq2[int, Tarea] {
returnfunc(yield func(int, Tarea) bool) {
for _, t := range ts {
if !yield(t.ID, t) {
return
}
}
}
}
funcmain() {
ts := []Tarea{{ID: 10, Titulo: "Comprar pan"}, {ID: 20, Titulo: "Repasar Go"}}
for id, t := rangePorID(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ón
Qué da
En 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 fijo
array_keys($m)
slices.Collect(seq)
Un slice con todo lo del iterador
iterator_to_array($gen, false)
slices.Sorted(seq)
Un slice ordenado con todo lo del iterador
iterator_to_array() + sort()
Gomain.go
package main
import (
"fmt""maps""slices"
)
funcmain() {
// 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.
PHP
Go
Qué 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 IteratorAggregate
mé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 · ✓ Resuelto
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
Pista. Un for i := desde; i <= hasta; i++ que haga if !yield(i) { return } en cada vuelta.
Reto 2 de 5 · ✓ Resuelto
Solo las pendientes
Completa Pendientes(ts []Tarea) iter.Seq[Tarea] para que entregue solo las tareas con Hecha a false, en orden. Es el generator pendientes() de PHP que hace yield dentro de un if.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Antes del yield, sáltate las hechas con if t.Hecha { continue }.
Reto 3 de 5 · ✓ Resuelto
Numera la lista
Completa ConPosicion(ts []Tarea) iter.Seq2[int, string] para que entregue parejas (posición, título) empezando a contar en 1, como en una lista para personas: 1 Comprar pan, 2 Repasar Go. Es el yield $posicion => $tarea->titulo de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. El índice de range empieza en 0; entrega i+1.
Reto 4 de 5 · ✓ Resuelto
Solo las primeras
Completa Primeras(n int, seq iter.Seq[Tarea]) iter.Seq[Tarea]: un iterador que entrega solo las n primeras tareas de seq y luego para, aunque seq tenga más. Si n es 0 o menos, no entrega ninguna. Es el LIMIT n de SQL, o un generator de PHP que hace return tras nyield.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Lleva la cuenta de las que has entregado y haz return al llegar a n. No olvides el caso n <= 0: sal antes de recorrer nada.
Reto 5 de 5 · ✓ Resuelto
Tu array_map perezoso
Completa la función genérica Mapear[V, W any](seq iter.Seq[V], f func(V) W) iter.Seq[W]: un iterador que entrega f(v) por cada v de seq. Por ejemplo, de tareas a títulos. Es el array_map() de PHP, pero sin montar ningún array: junta closures, genéricos e iteradores.
Al pulsar Comprobar, unos tests ocultos prueban tu código con el compilador oficial de Go.
Gomain.go · editable
Pista. Recorre seq con for v := range seq y entrega f(v) con el if !yield(…) { return } de siempre.
Resumen
Lo que te llevas de esta lección
Un iterador es iter.Seq[T]: una función que recibe yield (en PHP, una función con yield que devuelve Generator).
Se recorre con for t := range seq (en PHP, foreach ($gen as $t)).
if !yield(t) { return }: cuando el bucle hace break, el iterador para (en PHP, el generator se queda dormido).
iter.Seq2[K, V] entrega parejas (en PHP, yield $k => $v).
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 }.