Saltar al contenido
Iteradores y generadores

Generadores y yield

Lección 2 de 412 min4 ejercicios

Escribir un iterador a mano, con su next() y su { value, done }, es mucho código para algo simple. Un generador lo hace por ti: es una función que puede pausarse en medio, entregar un valor y retomar después desde ese mismo punto, con todas sus variables intactas.

Qué mirar en el pizarrón

Fíjate en cuándo entra y sale el generador de la pila. En cada yield sale sin terminar, y en cada next() vuelve a entrar en el punto donde quedó.

En el pizarrón

function* contar() {  console.log("arranca");  yield 1;  console.log("sigue");  yield 2;  console.log("termina");} const gen = contar();console.log(gen.next().value);console.log(gen.next().value);console.log(gen.next().done);

Pilacima

    La pila está vacía.

    Consola(vacía)

    Llamar a una función generadora no ejecuta su cuerpo: devuelve un objeto generador, en pausa antes de la primera línea. La pila sigue vacía.

    Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

    Ver todos los pasos en texto
    1. Paso 1: Llamar a una función generadora no ejecuta su cuerpo: devuelve un objeto generador, en pausa antes de la primera línea. La pila sigue vacía. Pila: vacía.
    2. Paso 2: El primer next() pone el generador en la pila y ejecuta su cuerpo desde el principio. Pila: contar().
    3. Paso 3: yield 1 entrega el valor 1 y pausa el generador justo ahí. Pila: contar().
    4. Paso 4: El generador sale de la pila, pero no termina: su contexto, con sus variables y la línea donde quedó, se guarda aparte. next() devuelve { value: 1, done: false }. Pila: vacía.
    5. Paso 5: El segundo next() vuelve a poner el generador en la pila y lo retoma donde quedó, en la línea 4, no desde el principio. Pila: contar().
    6. Paso 6: yield 2: entrega el 2 y vuelve a pausarse. Pila: vacía.
    7. Paso 7: El tercer next() retoma en la línea 6. Ya no hay más yield: la función llega al final. Pila: contar().
    8. Paso 8: Terminó de verdad: next() devuelve { value: undefined, done: true }. Un generador es una función que se puede pausar y retomar, y produce valores de a uno, solo cuando se los piden. Pila: vacía.

    function* y yield

    Una función generadora se escribe con un asterisco. Dentro, yield entrega un valor y pausa:

    function* semaforo() {
      yield "verde";
      yield "amarillo";
      yield "rojo";
    }
    
    const s = semaforo();
    console.log(s.next());
    console.log(s.next().value);
    
    for (const luz of semaforo()) {
      console.log(luz);
    }

    Llamar a semaforo() no ejecuta nada: devuelve un generador, que es a la vez un iterador (tiene next()) y un iterable (funciona con for...of). Como viste en el pizarrón, el cuerpo avanza solo hasta el siguiente yield cada vez que alguien pide un valor.

    Lo que ahorra

    El rango del tema anterior, con un generador:

    function* rango(desde, hasta) {
      for (let n = desde; n <= hasta; n++) {
        yield n;
      }
    }
    
    console.log([...rango(1, 5)]);

    Y como método iterable de un objeto, con la sintaxis *[Symbol.iterator]():

    const playlist = {
      canciones: ["Intro", "Tema 1", "Final"],
      *[Symbol.iterator]() {
        for (const c of this.canciones) yield `♪ ${c}`;
      },
    };
    
    console.log([...playlist]);

    Secuencias infinitas

    Como un generador solo avanza cuando le piden un valor, puede describir secuencias sin fin:

    function* fibonacci() {
      let [a, b] = [0, 1];
      while (true) {
        yield a;
        [a, b] = [b, a + b];
      }
    }
    
    const fib = fibonacci();
    const primeros = [];
    for (let i = 0; i < 10; i++) primeros.push(fib.next().value);
    console.log(primeros);

    yield* para delegar

    yield* entrega, uno por uno, todos los valores de otro iterable o generador:

    function* vocales() {
      yield* "aeiou";
    }
    
    function* abecedarioCorto() {
      yield "inicio";
      yield* vocales();
      yield* [1, 2];
      yield "fin";
    }
    
    console.log([...abecedarioCorto()].join(" "));

    Es útil para recorrer estructuras recursivas, como un árbol:

    function* recorrer(nodo) {
      yield nodo.nombre;
      for (const hijo of nodo.hijos) yield* recorrer(hijo);
    }
    
    const carpeta = { nombre: "src", hijos: [{ nombre: "app.js", hijos: [] }, { nombre: "lib", hijos: [{ nombre: "util.js", hijos: [] }] }] };
    console.log([...recorrer(carpeta)]);

    return en un generador

    Un return termina el generador. Su valor aparece en el último next(), con done: true, pero for...of y el spread lo ignoran:

    function* corto() {
      yield 1;
      return 99;
    }
    
    const g = corto();
    console.log(g.next(), g.next());
    console.log([...corto()]);

    Resumen

    • function* define un generador; llamarlo no ejecuta nada.
    • yield valor entrega el valor y pausa; next() retoma donde quedó.
    • Un generador es iterador e iterable a la vez, y de un solo uso.
    • Pueden ser infinitos: solo avanzan cuando les piden valores.
    • yield* delega en otro iterable; return termina, y su valor no se recorre.

    ¡A practicar!

    Tu progreso se guarda en este navegador.

    Autoevaluación: Funciones que se pausan

    Elige una respuesta en cada pregunta.

    1. ¿Qué pasa al llamar a una función generadora, function* gen() {…}?

    2. ¿Qué hace yield valor?

    3. ¿Puede un generador tener un while (true) sin colgar el programa?

    4. ¿Qué hace yield* otroIterable?

    Ordena la salida: Consumir un generador

    Un generador consumido de a poco y uno nuevo. Ordena lo que aparecería en la consola.

    function* letras() {  yield "a";  yield "b";  return "fin";} const g = letras();console.log(g.next().value);console.log([...g].join(","));console.log(g.next().done);console.log([...letras()].length);

    Consola, de arriba abajo

    1. true
    2. a
    3. 2
    4. b

    Detective: Un generador ya consumido

    El largo se imprime bien, pero el primer número desaparece. Encuentra la línea que provoca el problema y elige el arreglo.

    Consola

    2
    numeros.js:9
    console.log(primero.toFixed(1));
                        ^
    
    TypeError: Cannot read properties of undefined (reading 'toFixed')

    Paso 1: toca la línea de código que causa el error.

    Laboratorio: Identificadores sin fin

    Escribe el generador idsUnicos(prefijo): una secuencia infinita de identificadores.

    programa.jsse ejecuta mientras escribes

    $ node programa.js

    (escribe tu código: se ejecuta solo)

    Lo que debe cumplir

    • Imprime pedido-1 y pedido-2 (pendiente)
    • No se termina: el valor 100 es x-100 (pendiente)
    • Es una función generadora con yield (pendiente)

      domina-js · JavaScript en español, gratis y paso a paso.