No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

ES6: generator

15/35
Recursos

Los generadores son funciones especiales que pueden pausar su ejecuci贸n, luego volver al punto donde se quedaron, recordando su scope y seguir retornando valores.

Estos se utilizan para guardar la totalidad de datos infinitos, a trav茅s de una funci贸n matem谩tica a valores futuros. De esta manera ocupan poca memoria, con respecto a si creamos un array u objeto.

C贸mo utilizar generadores

La sintaxis de los generadores comprende lo siguiente:

  • La palabra reservada function* (con el asterisco al final).
  • La palabra reservada yield que hace referencia al valor retornado cada vez que se invoque, recordando el valor anterior.
  • Crear una variable a partir de la funci贸n generadora.
  • El m茅todo next devuelve un objeto que contiene una propiedad value con cada valor de yield; y otra propiedad done con el valor true o false si el generador ha terminado.

Si el generador se lo invoca y ha retornado todos sus valores de yield, entonces devolver谩 el objeto con las propiedades value con undefined y un done con true.

// Declaraci贸n
function* nombre(par谩metros){
    yield (primer valor retornado)
    yield (segundo valor retornado)
    ...
    yield (煤ltimo valor retornado)

}

//Crear el generador
const generador = nombre(argumentos)

// Invocacioens
generador.next().value //primer valor retornado
generador.next().value //segundo valor retornado
...
generador.next().value //煤ltimo valor retornado

Ejemplo de un generador

Por ejemplo, creemos un generador para retornar tres valores.

function* generator(){
    yield 1
    yield 2
    yield 3
}

const generador = generator()

generador.next().value //1
generador.next().value //2
generador.next().value //3
generador.next() // {value: undefined, done: true}

C贸mo utilizar for of y for in

Existen dos nuevas formas de utilizar ciclos repetitivos. El bucle for valor of iterable recorre iterables, como arrays, Map, Set e incluso un generador.

El valor es cada elemento del iterable puede tener cualquier nombre, por eso se inicia con let nombre.

const array = [5, 4, 3, 2, 1]

for (let numero of array) {
  console.log(numero) // 5 4 3 2 1
}

Sin embargo, debes tener en cuenta que solo podr谩s acceder a sus valores, y no a sus referencias, por lo que si quieres cambiar los elementos del array, necesitar谩s un 铆ndice array[indice].

for (let numero of array) {
  valor *= 2 
  console.log(numero) // 10 8 6 4 2
}
 
console.log(array) // [ 5, 4, 3, 2, 1 ]

Si intentas recorrer un objeto de esta forma for elemento of objeto, te ocurrir谩 un error, porque un objeto no es un iterable. En su lugar puedes utilizar for elemento in objeto, que recorrer谩 las propiedades del objeto.

const objeto = { a: 1, b: 2, c: 3 }

for (let elemento in objeto) {
  console.log(elemento) // 'a' 'b' 'c'
}

Sin embargo, si utilizas for elemento in array, no dar谩 un error, pero el resultado no ser谩 el esperado, ya que los arrays son un tipo de objeto donde cada propiedad es el 铆ndice del valor del array o del iterable. Por lo que debes tener cuidado.

const array = [5, 4, 3, 2, 1]

for (let elemento in array) {
  console.log(elemento) // '0' '1' '2' '3' '4'
}

/* const array = {
	'0': 5,
  '1': 4,
  '2': 3,
  '3': 2,
  '4': 1
}*/

Contribuci贸n creada por Andr茅s Guano (Platzi Contributor).

Aportes 43

Preguntas 6

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

For of y for in

Si no entendiste ese ciclo for dejame explicarte. Ese bucle for valor of iterable recorre iterables, como arrays, Map o Set. El valor es cada elemento del iterable puede tener cualquier nombre, por eso se inicia con let nombre.

const array = [5, 4, 3, 2, 1]

for (let numero of array) {
  console.log(numero) // 5 4 3 2 1
}

Sin embargo, debes tener en cuenta que solo podr谩s acceder a sus valores, y no a sus referencias, por lo que si quieres cambiar los elementos del array, necesitar谩s un 铆ndice array[indice].

for (let numero of array) {
  valor *= 2 
  console.log(numero) // 10 8 6 4 2
}
 
console.log(array) // [ 5, 4, 3, 2, 1 ]

Si intentas recorrer un objeto de esta forma for elemento of objeto, te ocurrir谩 un error, porque un objeto no es un iterable. En su lugar puedes utilizar for elemento in objeto, que recorrer谩 las propiedades del objeto.

const objeto = { a: 1, b: 2, c: 3 }

for (let elemento in objeto) {
  console.log(elemento) // 'a' 'b' 'c'
}

Sin embargo, si utilizas for elemento in array, no dar谩 un error, pero el resultado no ser谩 el esperado, ya que los arrays son un tipo de objeto donde cada propiedad es el 铆ndice del valor del array o del iterable. Por lo que debes tener cuidado.

const array = [5, 4, 3, 2, 1]

for (let elemento in array) {
  console.log(elemento) // '0' '1' '2' '3' '4'
}

/* const array = {
	'0': 5,
  '1': 4,
  '2': 3,
  '3': 2,
  '4': 1
}*/

Si algun otro como yo, lleg贸 a esta clase sin saber que es un generdor, aqu铆 les dejar茅 dos enlaces que les podr谩n ayudar a comprender qu茅 son, para qu茅 se usan, y como usarlos.

Explicaci贸n detallada de qu茅 son, c贸mo se usan, para qu茅 se usan: https://www.digitalocean.com/community/tutorials/understanding-generators-in-javascript-es

Explicaci贸n de la implementaci贸n de los generadores: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Generator

Hola Chi@s 馃槂
ES6: Generator

function* iterate(array)  {
    for (let value of array) {
        yield value;
    }
}

const it = iterate(["Oscar", "Alexa", "David", "Gerlis"]);
console.log(it.next().value);
console.log(it.next().value);
console.log(it.next().value); ```

IMO generator tiene una especie de lifecycle (no se explica como tal) pero es una buena manera de entenderlo, te dejo una descripci贸n gr谩fica

La palabra clave **yield **detiene la ejecuci贸n de la funci贸n generadora y el valor de la expresi贸n que sigue a la palabra clave yield se devuelve

yield <expression>

Si expression se omite, devuelve undefined en su lugar.

Para entender las clases me est谩 resultando m谩s f谩cil/pr谩ctico leer la descripci贸n en los Recursos. A veces siento que el profe se enreda mucho.

No me cansar茅 de comentarlo, explicaciones pobres. Nuevamente me voy a youtube a entender cada aspecto con claridad.

Bueno, yo lo veo as铆, los generators son un tipo de funci贸n nivel super saiyayin 2 que puede arrojar los valores de retorno seg煤n se le pida, decid铆 pasar otro array como parametro y no pens茅 que tambi茅n me tomar铆a los valores de rotorno hechos en otro for

function* iterate(array, array2){
    for (let value of array){
        yield value;
    }
    for(let value2 of array2){
        yield value2;
    }
}

const it = iterate(['Angel','Juan','V铆ctor','Marcos'], ['Angela', 'Juana', 'V铆ctoria', 'Mar铆a']);
console.log(it.next().value);
console.log(it.next().value);
console.log(it.next().value);
console.log(it.next().value);
console.log(it.next().value);
console.log(it.next().value);
console.log(it.next().value);
console.log(it.next().value);
console.log(it.next().value);
console.log(it.next().value);

El metodo next es 1 de 4 que pueden ser utilizados 馃槂
https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Generator

Les dejo un video que ayuda a entender mejor los Generators

https://youtu.be/tEkWs8RCkQQ

Hay diferentes motivos por los que se usan estos generadores, uno de ellos es imaginarse una lista muy grande, de esta forma solo carga en memoria el siguiente valor, ahorrando asi recursos de la maquina

En la clase le entiendo a los ejemplos, los conceptos los entiendo solo en el aporte bajo la clase.

https://www.youtube.com/watch?v=wl6X2XFnNtY&t=186s

Una explicaci贸n fenomenal para entender las funciones generadoras. Un buen complemento a esta clase si es que quieres ser un verdadero experto en javascript.

Generator nos va a permitir tener una funci贸n, de tipo especial, que nos va ar retornar una serie de valores seg{un el algoritmo dado, recordando este recurso.

Que triste que este curso se explique tan a la ligera.

ES6: generators

En ES6 (EcmaScript 2015), se introdujeron los generadores, que son una caracter铆stica poderosa para trabajar con secuencias de valores de una manera controlada y pausada. Los generadores permiten crear funciones especiales que pueden pausarse y reanudarse durante su ejecuci贸n, lo que facilita la creaci贸n de iteradores personalizados y tareas asincr贸nicas.

Un generador se define utilizando una funci贸n especial llamada function*, y dentro de esta funci贸n, puedes usar la palabra clave yield para producir valores y pausar la ejecuci贸n. Aqu铆 hay un ejemplo b谩sico:

function* contador() {
  let i = 0;
  while (true) {
    yield i;
    i++;
  }
}

const iterador = contador();

console.log(iterador.next().value); // 0
console.log(iterador.next().value); // 1
console.log(iterador.next().value); // 2
// Y as铆 sucesivamente...


En este ejemplo, la funci贸n generadora contador produce una secuencia infinita de n煤meros, pausando la ejecuci贸n despu茅s de cada yield.

Los generadores son especialmente 煤tiles cuando se trata de tareas asincr贸nicas, ya que permiten escribir c贸digo as铆ncrono de manera m谩s secuencial y comprensible. Por ejemplo, aqu铆 hay un ejemplo simplificado de c贸mo podr铆as usar un generador para controlar tareas asincr贸nicas:

function* tareaAsincronica() {
  const resultado1 = yield obtenerResultado1();
  const resultado2 = yield obtenerResultado2(resultado1);
  return resultado2;
}

const iterador = tareaAsincronica();

iterador.next().value.then(resultado1 => {
  iterador.next(resultado1).value.then(resultado2 => {
    const resultadoFinal = iterador.next(resultado2).value;
    console.log(resultadoFinal);
  });
});


En este ejemplo, el generador tareaAsincronica controla la ejecuci贸n de dos tareas asincr贸nicas (obtenerResultado1 y obtenerResultado2) de manera secuencial, pausando la ejecuci贸n en cada yield hasta que se resuelvan las promesas.

Los generadores son una herramienta poderosa en JavaScript que pueden mejorar la legibilidad y la l贸gica de c贸digo complejo, especialmente cuando se trabaja con tareas secuenciales o asincr贸nicas.


Este es un concepto algo avanzado, supongo que lo entenderemos con el pasar del tiempo. 馃憖


Sigamos aprendiendo JavaScript. 馃懆鈥嶐煉

Generator

Los generadores se definen utilizando la palabra clave function* en lugar de simplemente function. Dentro de un generador, puedes usar la palabra clave yield para pausar la ejecuci贸n y devolver un valor. Posteriormente, puedes reanudar la ejecuci贸n del generador y pasar datos nuevamente utilizando el m茅todo next().
ChatGPT

con esta explicacion me quedo mucho mas claro el funcionamiento de los generadores

Los generadores en JavaScript son funciones especiales que permiten la pausa y la reanudaci贸n de la ejecuci贸n. A diferencia de las funciones regulares, que se ejecutan de principio a fin y devuelven un valor, los generadores pueden producir m煤ltiples valores a lo largo del tiempo. Un generador se define utilizando la palabra clave `function*` seguida del nombre de la funci贸n y los par谩metros, si los hay. Dentro del generador, se utilizan las palabras clave `yield` y `return` para controlar la generaci贸n de valores y la finalizaci贸n del generador, respectivamente. Aqu铆 tienes un ejemplo de c贸mo se puede utilizar un generador para generar una secuencia de n煤meros: ```js function* numeros() { yield 1; yield 2; yield 3; } const generador = numeros(); console.log(generador.next()); // { value: 1, done: false } console.log(generador.next()); // { value: 2, done: false } console.log(generador.next()); // { value: 3, done: false } console.log(generador.next()); // { value: undefined, done: true } ```En este ejemplo, la funci贸n `numeros` es un generador que produce los n煤meros 1, 2 y 3 utilizando la palabra clave `yield`. Al llamar al generador y asignarlo a la variable `generador`, podemos obtener los valores generados utilizando el m茅todo `next()`. Cada llamada al m茅todo `next()` devuelve un objeto con una propiedad `value` que contiene el valor generado y una propiedad `done` que indica si el generador ha terminado. Los generadores son 煤tiles cuando se necesita generar secuencias de valores que no est谩n disponibles de inmediato o cuando se desea controlar el flujo de ejecuci贸n de manera m谩s granular. Adem谩s, los generadores pueden ser utilizados en combinaci贸n con otras caracter铆sticas de JavaScript, como las promesas, para crear c贸digo as铆ncrono m谩s legible y f谩cil de mantener.

Queria comentar que despues de esta clase, tuve que indagar mas en el tema y si quieren saber mas sobre las funciones generadoras les recomiendo estos enlaces

https://www.youtube.com/watch?v=wl6X2XFnNtY
https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Operators/yield
https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Generator

鉁煢凥ay varias cosas que recalcar sobre los generadores:

  • Cuando se utiliza la palabra reservada yield, se retorna el valor actual del generador y se pausa la ejecuci贸n del mismo, por lo que cuando se vuelve a llamar al generador con next(), este se ejecutar谩 desde la siguiente l铆nea del 煤ltimo yield. Es por eso que cada vez que usamos next(), nos retorna el siguiente valor del generador, debido a que yieldse encuentra en un ciclo for of

  • Estos se pueden anidar, es decir, que se puede ejecutar m谩s generadores mientras ya hay uno en ejecuci贸n.

  • 驴Qu茅 es un generador?
    Un generador es una funci贸n que puede detenerse a la mitad y luego continuar desde donde se detuvo. En resumen, un generador parece ser una funci贸n pero se comporta como un iterador.

  • Casos donde los generadores son 煤tiles.
    Los generadores son 煤tiles cuando se trata de secuencias infinitas, ejecuci贸n diferida, c贸mputos masivos, operaciones asincr贸nicas, etc.

  • 驴C贸mo crear un generador?
    Se crea un generador agregando un asterisco (*) a la palabra clave de la funci贸n. Una funci贸n generadora puede tener una o m谩s expresiones de rendimiento. Se utiliza una expresi贸n de rendimiento para pausar el generador y proporciona un valor a la persona que llama. La expresi贸n de rendimiento se utiliza para producir una secuencia de valores.

Generator
.
Un generador en JavaScript es una funci贸n que puede pausar su ejecuci贸n y luego reanudarla m谩s tarde. La funci贸n se ejecuta hasta encontrar una declaraci贸n yield, momento en el cual se pausa y devuelve el valor especificado por yield. Luego, cuando se llama al m茅todo next() en el iterador devuelto por el generador, la funci贸n se reanuda desde el punto en el que se detuvo y contin煤a ejecut谩ndose hasta encontrar la siguiente declaraci贸n yield.
.
El generador mantiene su estado interno, lo que significa que puede recordar las variables y el contexto en el que se encontraba cuando se paus贸. Esto permite que el generador produzca una secuencia de valores a medida que se llama repetidamente a next().
.
Cada vez que se hace .next(), se devuelve un objeto con dos propiedades: value, que contiene el valor actual del iterador, y done, que indica si se ha alcanzado el final del iterador.
.
En resumen, un generador es una forma de producir una secuencia de valores a medida que se necesitan, pausando y reanudando su ejecuci贸n seg煤n sea necesario. Es una herramienta poderosa para trabajar con secuencias o iterables en JavaScript.

Los generadores en JavaScript son funciones especiales que pueden ser pausadas y reanudadas en diferentes puntos de ejecuci贸n. Estas funciones generan una secuencia de valores en lugar de devolver un solo valor.

Aqu铆 hay algunos conceptos clave para entender los generadores en JavaScript:

  1. Funciones especiales: Los generadores se definen usando la sintaxis function*. Por ejemplo, function* miGenerador() { ... }.

  2. Valores m煤ltiples: A diferencia de las funciones regulares que devuelven un solo valor y finalizan, los generadores pueden generar una secuencia de valores usando la palabra clave yield. El yield pausa la ejecuci贸n del generador y devuelve un valor. Luego, se puede reanudar desde el punto de pausa para generar el siguiente valor.

  3. Iteraci贸n controlada: Los generadores se utilizan junto con un iterador para recorrer la secuencia de valores generados. Un iterador es un objeto que implementa el protocolo de iteraci贸n y proporciona los m茅todos next(), return() y throw().

  4. Pausa y reanudaci贸n: Los generadores pueden ser pausados en cualquier momento utilizando yield y reanudados m谩s tarde cuando se invoca el m茅todo next() en el iterador asociado. Cada vez que se llama a next(), el generador se ejecuta hasta encontrar la pr贸xima declaraci贸n yield, donde se pausa nuevamente y devuelve un objeto con el valor generado y un indicador done que indica si el generador ha terminado.

  5. Control de flujo flexible: Los generadores permiten un control de flujo m谩s flexible, ya que puedes pausar la ejecuci贸n en cualquier momento, realizar acciones adicionales y luego reanudar desde donde se dej贸.

Los generadores son 煤tiles para trabajar con secuencias de valores grandes o infinitas, realizar iteraciones personalizadas y manejar el control de flujo complejo. Al utilizar generadores, puedes escribir c贸digo m谩s legible y eficiente al evitar generar y almacenar todos los valores de una vez. Un ejemplo de como se usa de una forma avanzada es:

function fibonacci() {
  var a = yield 1;
  yield a * 2;
}

var it = fibonacci();
console.log(it);          // "Generator {  }"
console.log(it.next());   // 1
console.log(it.send(10)); // 20
console.log(it.close());  // undefined
console.log(it.next());   // throws StopIteration (as the generator is now closed)

Si quieren investigar m谩s vayan a https://developer.mozilla.org

que pasa si no le pongo el signo * a la function

otra forma

function* generateNumbers(){
    yield 1;
    yield 2;
    yield 3;
    yield 4;
}
const numbers = generateNumbers();
for (let i=0; i<4; i++){
    console.log(numbers.next().value);
}
const array2 = { a: 1, b: 2, c: 3 };

console.log('{');

for (let obj in array2) {
  for (let i = 0; i < Object.keys(array2).length; i++) {
    if (obj.match(Object.keys(array2)[i])) {
      console.log(`[${obj} : ${Object.values(array2)[i]}]${obj.length >= i ? "," : ""}`);
    }
  } 
}

console.log('}');

Consola:
{
[a : 1],
[b : 2],
[c : 3]
}

const array1 = [5, 4, 3, 2, 1];

for (let numero of array1) {
  console.log(numero);
}

Consola:
5
4
3
2
1

馃搧 Archivos del Proyecto 馃搧


Pasos 馃搶

  • 鈥 Dentro de la carpeta es6, crear el archivo llamado: 09-generator.js
      • 鈼 El c贸digo queda:
//Compilar: seleccionar el c贸digo + click derecho + Run Code

//Ejercicio #1

function* iterate(array){
	for(let value of array){
		yield value;
	}
}

const it = iterate(['Oscar', 'David', 'Ana', 'Ulises', 'Jennifer']);
console.log(it.next().value);

/*output:
Oscar
*/

console.log(it.next().value);

/*output:
David
*/

console.log(it.next().value);

/*output:
Ana
*/

console.log(it.next().value);

/*output:
Ulises
*/

console.log(it.next().value);

/*output:
Jennifer
*/

console.log(it.next().value);

/*output:
undefined
*/

1. for鈥f con generadores:

El bucle for鈥f se utiliza para iterar sobre los valores generados por un generador. Para ello, necesitaremos que el generador implemente un iterador. El iterador se logra agregando un m茅todo especial Symbol.iterator a nuestro generador.

Aqu铆 tienes un ejemplo de c贸mo usar for鈥f con un generador:

function* miGenerador() {
  yield 'Hola';
  yield 'mundo';
  yield 'generador!';
}

const generador = miGenerador();

for (const valor of generador) {
  console.log(valor); // Imprime 'Hola', 'mundo', 'generador!'
}

En este ejemplo, definimos la funci贸n generadora miGenerador(). Luego, creamos un objeto generador llamado generador utilizando miGenerador(). Finalmente, utilizamos el bucle for鈥f para iterar sobre los valores generados por generador e imprimir cada valor en la consola.

2. for鈥n con generadores:

El bucle for鈥n se utiliza para iterar sobre las propiedades de un objeto, incluyendo los valores generados por un generador que est茅 asociado a una propiedad espec铆fica del objeto.

Aqu铆 tienes un ejemplo de c贸mo usar for鈥n con un generador:

const objeto = {
  a: 'Hola',
  b: 'mundo',
  c: 'generador!',
  *generador() {
    for (const propiedad in this) {
      yield this[propiedad];
    }
  }
};

for (const valor of objeto.generador()) {
  console.log(valor); // Imprime 'Hola', 'mundo', 'generador!'
}

En este ejemplo, creamos un objeto objeto que tiene tres propiedades (a, b y c). Adem谩s, el objeto tiene un m茅todo generador llamado generador() que utiliza un bucle for鈥n para iterar sobre las propiedades del objeto y generar los valores correspondientes.

Luego, utilizamos el bucle for鈥f para iterar sobre los valores generados por objeto.generador() e imprimir cada valor en la consola.

Este tema es un poco mas avanzado por lo que requiere una explicaci贸n completa o ampliada.

馃搼 DOC.

Conf.
馃嚞馃嚙 EN

Exp.
馃嚞馃嚙 EN
馃嚜馃嚫 ES

Este tema de los generadores tiene mucho por sacar :0

chicos si les cuesta mucho entenderlo de cero aqui, les dejo este video de midu que vi en youtube.
https://www.youtube.com/watch?v=wl6X2XFnNtY

Aporto Tablita de diferencias

Mi resumen:

15/35 ES6: generator

Los generadores son funciones especiales que pueden pausar su ejecuci贸n, recordar su contexto y luego continuar se ejecuci贸n desde donde se quedaron. Son 煤tiles para generar una cantidad infinita de valores a trav茅s de una funci贸n matem谩tica y ocupan poca memoria en comparaci贸n con otros m茅todos para almacenar una gran cantidad de valores. Los generadores se definen utilizando la palabra clave function* seguida de yield, que devuelve un valor cada vez que se llama a la funci贸n y recuerda el valor interior. Tambi茅n se pueden utilizar ciclos repetitivos como for of y for in para iterar a trav茅s de los valores de un generador o un iterable. Por ejemplo:

/function* generator () {

yield 1
yield 2
yield 3
}

const generator = generator()

console.log(generator.next().value) //1
console.log(generator.next().value) //2
console.log(generator.next().value) //3

console.log(generator.next()) //{value:undefined, done: true}

const array = [5, 4, 3, 2, 1]

for (let numero of array) {
	console.log(numero) // 5 4 3 2 1
}

const objeto = {a: 1, b: 2, c: 3}

for (let elemento in objeto) {
	console.log(elemento) // 'a' 'b' 'c'
}

for (let elemento in array) {
	console.log(elemento) // '0' '1' '2' '3' '4'
}

馃憥馃徏

Aqui les dejo un enlace a un video en donde hablan mas sobre las funciones generadores y como crear una estructura fibonaci con un generador. Este video es del canal midulive, se los recomiendo para ver mas cosas de programacion. Espero que les sea util 馃槂.

genial!

Algo muy interesante que pueden aplicar aqu铆, aunque es un tema que se entiende m谩s al hablar de Closures, es el Entorno L茅xico.
Les recomiendo mucho buscar informaci贸n sobre este tema para que entiendan como funciona JavaScript

Le dejo un link con algo de info:

Aqu铆 un ejemplo en c贸digo:

function* iterate(array)  {
    for (let value of array) {
        yield value;
    }
}

const it = iterate(["Oscar", "Alexa", "David", "Gerlis"]);
const it2 = iterate(["Perro", "Gato", "Ave", "Hamster", "Pollo"]);
console.log(it.next().value);
console.log(it2.next().value);
console.log(it.next().value);
console.log(it2.next().value);
console.log(it.next().value);
console.log(it2.next().value);
console.log(it.next().value);
console.log(it2.next().value);
console.log(it.next().value);
console.log(it.next().value);

console.log(it2.next().value);
console.log(it2.next().value);

El asterisco despu茅s de la palabra function es para definir la funci贸n como un generator, si se lo quitamos, nos va a dar un error.

Para complementar la clase y la expiaci贸n en los recursos vi este video donde hacen la serie fibonacci con un generator.

function* fibonacci() {
  // 0 1 1 2 3 5 8 13 ...
  let first = 0;
  let second = 1;

  yield first;
  yield second;

  while (true) {
    const sum = first + second;
    yield sum;

    first = second;
    second = sum;
  }
}

const fib = fibonacci()
console.log(fib.next().value);
console.log(fib.next().value);
console.log(fib.next().value);
console.log(fib.next().value);
console.log(fib.next().value);
console.log(fib.next().value);
console.log(fib.next().value);
console.log(fib.next().value);

Esto es muy similar a Python

Unos peque帽os experimentos:

function* iterate(array) {
    for (let value of array) {
        yield value;
    }
}

const it = iterate(['Oscar','David','Ana','Jenny']);
console.log(it.next().value);
console.log(it.value);
console.log(it.next());
console.log(it.next().value);
console.log(it.next().value);
console.log(it.next());
console.log(it);