No tienes acceso a esta clase

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

Compra acceso a todo Platzi por 1 a帽o

Antes: $249

Currency
$209/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscr铆bete

Termina en:

15D
14H
23M
10S

ES9: Promise.finally

23/35
Recursos

Las siguientes caracter铆sticas de ES9 o ES2018 que aprender谩s son: m茅todo finally para promesas y generadores as铆ncronos.

M茅todo finally en promesas

El m茅todo finally para promesas consiste en ejecutar c贸digo despu茅s que una promesa haya sido ejecutada como resuelta o rechazada.

promesa()
    .then(response => console.log(response) // Promesa resuelta
    .catch(error => console.log(response) // Promesa rechazada
    .finally( () => console.log("Finalizado") ) // C贸digo final  

Generadores as铆ncronos

Los generados as铆ncronos son semejantes a los generadores que ya conoces, pero combinando sint谩xis de promesas.

async function* anotherGenerator() {
  yield await Promise.resolve(1)
  yield await Promise.resolve(2)
  yield await Promise.resolve(3)
}

const generador = anotherGenerator()
generador.next().then(respuesta => console.log(respuesta.value))
generador.next().then(respuesta => console.log(respuesta.value))
generador.next().then(respuesta => console.log(respuesta.value))

C贸mo utilizar for await

De la misma manera, for await es un ciclo repetitivo que se maneja as铆ncronamente. El ciclo siempre debe estar dentro de una funci贸n con async.

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

async function forAwait() {
  const nombres = ["Alexa", "Oscar", "David"]
  for await (let valor of nombres) {
    console.log(valor)
  }
}

forAwait()

Cursos para entender el asincronismo en JavaScript

Si a煤n no sabes en qu茅 consiste el asincronismo, no te preocupes, existen cursos completos de este tema.

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

Aportes 37

Preguntas 7

Ordenar por:

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

o inicia sesi贸n.

En el minuto 2:53 dice que no entro en el catch鈥 OJO esto puede confundir! Si entro en el catch!..

Se genero un reject porque la condicion era false, por lo cual el catch lo ataja鈥

Una manera de verlo podria ser agregar marca en los console.log y probar los 2 casos鈥

const anotherFunction = () => {
    return new Promise((resolve, reject) => {
        if (true) {
            resolve("Hey");
        } else {
            reject("Whooops!");
        }
    })
}

anotherFunction()
    .then(response => console.log('Then...' + response))
    .catch(err => console.log('catch...' + err))
    .finally(()=> console.log('Finally'));

Nuevamente, siento que este concepto lo podemos ver como un lifecycle tambi茅n.

Malisima la parte del minuto 07:30 donde nos manda a probar algo que no funciona y en lugar de corregir el error vuelve atras鈥
Toda la parte de asincronismo en este curso es de muy mala a pesima!
O lo ponen despues del curso de asincronismo o lo editan. En realidad opino que ambas.

Hola Chicos 馃槂

ES9

  • Finally
const anotherFuncion = () => {
    return new Promise((resolve, reject) => {
        if (false) {
            resolve("hey!!");
        } else {
            reject ( "whooooops!");
        }
    })
}

anotherFuncion()
.then(response => console.log(response))
.catch(err => console.log(err))
.finally(() => console.log("finally"));
  • Async
async function* anotherGenerator() {
    yield await Promise.resolve(1);
    yield await Promise.resolve(2);
    yield await Promise.resolve(3);
}

const other = anotherGenerator();
other.next().then(response => console.log(response.value));
other.next().then(response => console.log(response.value));
other.next().then(response => console.log(response.value));
console.log("hello");

async function arrayOfNames(array) {
    for await (let value of array) {
        console.log(value);
    }
}

const names =arrayOfNames(["Alexa", "Oscar", "David"]);
console.log("After");

.finally es util cuando quieren hacer una acci贸n sin importar si la respuesta fue correcta o no. Tal vez el cierre de una conexi贸n a BD o actualizar un estado de loading cuando hicieron una llamada a la base de datos

No explica nada bien

Algo que no dijo el instructor, es que si vuelves a llamar la funcion con next, te devuelve undefined.

El finally se ejecuta Despues de que la promesa ocurre, independientemente si hubo un resolve o reject, si la promesa no ocurre entonces no entra en finally, para entenderlo agregue un setTimeout(), y probe con true y false:

const anotherFunction = () => {
    return new Promise((resolve, reject) => {
        if (true) {
            setTimeout(() => resolve('Hey!!'), 2000)
        } else {
            setTimeout(() => reject("Whooops!"), 5000)
        }
    })
}

anotherFunction()
    .then(response => console.log('Then...' + response))
    .catch(err => console.log('catch...' + err))
    .finally(()=> console.log('Finally'));

Modificaci贸n del c贸digo

En el minuto 7:00 le sale un error al profesor,le falt贸 mover el .value antes del .then().
Cuando usamos asyncy await en el generador, el .next() nos devuelve una promesa, pero cuando lo quitamos y se vuelve un generador normal, el .next() retorna un objeto con 2 propiedades, en nuestro caso:

{
value: Promise {1},
done: false
}

el value contiene lo que retornamos con yield, la propiedad done indica si a煤n tenemos valores para devolver con .next()

dicho esto, para que funcione como deber铆a solo tenemos que aumentar el .value antes del .then()

function* generator(){
    yield Promise.resolve(1);
    yield Promise.resolve(2);
    yield Promise.resolve(3);
}

const other = generator();
other.next().value.then(resp => console.log(resp));
other.next().value.then(resp => console.log(resp));
other.next().value.then(resp => console.log(resp));
console.log('Hello!');
/*Output: 
Hello!
1
2
3
*/

Nunca entend铆 como para qu茅 nos hizo quitar async y await, y luego no corri贸 y lo regres贸 como estaba antes. No s茅 qu茅 pas贸 ah铆 o qu茅 se pretend铆a probar. 驴Alguien me puede explicar?

Gente, la unica manera que mejoren este tipo de cursos es puntuarlos con la minima calificacion, de otra manera no creo que se den cuenta de lo que estan publicando.

Casi casi vuelve a hacer la performance de pasar del ejercicio 2 al 3!! Se ve por peque帽os momentos , pero lo corrige en plena grabaci贸n.

驴Cual ser谩n los misterios que ata帽an a la simbolog铆a numerol贸gica del 2? 驴Puede considerarse un ejercicio maldito?

Al eliminar el await del generador sigui贸 ejecutando bien 馃槖

async retorna un objeto Promise, por eso si funciona si quitamos el await

async function* generator(){
    yield Promise.resolve(1)
   yield Promise.resolve(2)
   
    
}

const gen= generator()

gen.next().then(x=>console.log(x.value))
gen.next().then(x=>console.log(x.value))

Promise.finally() es un m茅todo que se utiliza con promesas en JavaScript. Este m茅todo se encarga de agregar una funci贸n de devoluci贸n de llamada (callback) que se ejecutar谩 siempre, ya sea que la promesa se resuelva o se rechace. En otras palabras, Promise.finally() te permite ejecutar c贸digo una vez que una promesa haya terminado su ejecuci贸n, independientemente de si se resuelve o se rechaza. Esto es 煤til para realizar tareas de limpieza o acciones que deben realizarse en cualquier caso, como cerrar recursos o manejar errores finales.
La sintaxis b谩sica de Promise.finally() es la siguiente:

miPromesa
  .then(resultado => {
    // Hacer algo con el resultado si la promesa se resuelve
  })
  .catch(error => {
    // Manejar el error si la promesa se rechaza
  })
  .finally(() => {
    // C贸digo que se ejecutar谩 siempre, tanto si la promesa se resuelve como si se rechaza
  });

Aqu铆 hay un ejemplo m谩s completo:

const miPromesa = new Promise((resolve, reject) => {
  // Simulamos una operaci贸n asincr贸nica exitosa
  setTimeout(() => {
    resolve('隆Promesa resuelta!');
  }, 1000);
});

miPromesa
  .then(resultado => {
    console.log(resultado);
  })
  .catch(error => {
    console.error('Error:', error);
  })
  .finally(() => {
    console.log('Operaci贸n finalizada, independientemente de si se resuelve o se rechaza.');
  });

En este ejemplo, el c贸digo dentro del bloque .finally() se ejecutar谩 siempre, ya sea que la promesa se resuelva o se rechace. Puedes usarlo para realizar acciones como limpieza de recursos o registro de eventos independientemente del resultado de la promesa.

Promise.finally() es especialmente 煤til cuando deseas asegurarte de que ciertas acciones se realicen en cualquier caso, lo que mejora la gesti贸n y la predictibilidad del flujo de tu c贸digo.

Incre铆ble la cantidad de errores que tiene esta clase, lo peor de todo es que hay comentarios de hace 9 meses, 6 meses que recalcan los errores del profesor y Platzi no actualiza las clases鈥

Ok, est谩 bien, todos somos humanos y nos equivocamos, pero esta es una escuela, y si los alumnos notas los errores y los hacen p煤blicos, al menos se espera que la plataforma revise el feedback y haga la respectiva actualizaci贸n鈥

Sin palabras Platzi, me pregunto si realmente leen los comentarios o de nada sirve鈥

OJO! si ponemos ; en .then o .catch, nos larga error. aparentemente en este caso si importan los ; je

medueleelcerebeloxd

pero tan interesantes las clases 馃槃

Ejemplo Panaderia

Ejemplo de c贸mo se podr铆an utilizar las funciones as铆ncronas en un escenario relacionado con una panader铆a, donde se realiza un pedido de productos de manera as铆ncrona:

// Simulaci贸n de productos de la panader铆a
const bakeryProducts = [
  { id: 1, name: 'Pan de trigo', price: 2.5 },
  { id: 2, name: 'Croissant', price: 1.75 },
  { id: 3, name: 'Tarta de manzana', price: 10.0 }
];

function getBakeryProduct(productId) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const product = bakeryProducts.find(p => p.id === productId);

      if (product) {
        resolve(product);
      } else {
        reject(new Error('El producto no est谩 disponible en la panader铆a.'));
      }
    }, 1000);
  });
}

async function placeOrder() {
  try {
    console.log('Iniciando el pedido...');
    const product1 = await getBakeryProduct(1);
    console.log(`Producto 1: ${product1.name}`);

    const product2 = await getBakeryProduct(2);
    console.log(`Producto 2: ${product2.name}`);

    const product3 = await getBakeryProduct(3);
    console.log(`Producto 3: ${product3.name}`);

    console.log('Pedido completado.');
  } catch (error) {
    console.error(`Error al realizar el pedido: ${error.message}`);
  }
}

placeOrder();

En este ejemplo, tenemos un array ficticio llamado bakeryProducts que contiene productos de una panader铆a. La funci贸n getBakeryProduct(productId) simula una solicitud as铆ncrona para obtener un producto espec铆fico a partir de su productId. Utilizamos setTimeout para simular una demora de 1 segundo antes de resolver o rechazar la promesa, y luego buscamos el producto correspondiente en el array bakeryProducts.

La funci贸n placeOrder() es una funci贸n as铆ncrona que representa el proceso de realizar un pedido en la panader铆a. Dentro de ella, utilizamos await junto con getBakeryProduct() para obtener los productos de forma secuencial y esperar a que cada solicitud as铆ncrona se resuelva antes de continuar con la siguiente.

En el bloque try, mostramos en la consola el progreso del pedido, obteniendo y mostrando los nombres de los productos solicitados. Si ocurre alg煤n error durante el proceso de obtenci贸n de los productos, se captura en el bloque catch y se muestra un mensaje de error.

Al ejecutar el c贸digo, obtendr铆amos la siguiente salida:

Iniciando el pedido...
Producto 1: Pan de trigo
Producto 2: Croissant
Producto 3: Tarta de manzana
Pedido completado.

馃摑 Archivos del Proyecto 馃摑


Pasos 馃搶

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

//Ejercicio #1
const anotherFunction = () => {
	return new Promise((resolve, reject) => {
		if(true) {
			resolve('Hey!!');
		} else {
			reject('Whoooops!');
		}
	})
}

anotherFunction()
	.then(response => console.log(response))
	.catch(err => console.log(err))
	.finally(() => console.log('Finnaly'));

/*output con if(true):
Hey!!
Finnaly
*/

/*output con if(false):
Whoooops!
Finnaly
*/

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

//Ejercicio #1

async function* anotherGenerator() {
yield await Promise.resolve(1);
yield await Promise.resolve(2);
yield await Promise.resolve(3);

}

//Si se quita los async-await, al compila da un error por seguir usando .then
const other = anotherGenerator();
other.next().then(response => console.log(response.value));
other.next().then(response => console.log(response.value));
other.next().then(response => console.log(response.value));
console.log('Hello!');

/*output:
Hello!
1
2
3
*/

//Ejercicio #2
async function arrayOfNames(array) {
for await (let value of array) {
console.log(value);
}
}

const names = arrayOfNames(['Oscar', 'David', 'Ana']);
console.log('After');

/*output:
After
Oscar
David
Ana
*/

La forma correcta para hacer funcionar nuestro codigo es esta sin tener que usar el await y async

other.next().value.then(...)

Por fin 00, 01, 02 y 03 juntas !!!

ES9: Promise.finally

ES9 introdujo el m茅todo finally para objetos Promise en JavaScript. Este m茅todo se utiliza para especificar un bloque de c贸digo que se ejecutar谩 siempre, sin importar si la promesa se resuelve o se rechaza. En otras palabras, el bloque de c贸digo dentro de finally se ejecutar谩 despu茅s de que la promesa haya sido resuelta o rechazada, independientemente del resultado.

Aqu铆 tienes un ejemplo de c贸mo se usa Promise.finally en JavaScript:

const miPromesa = new Promise((resolver, rechazar) => {
    // Simulamos una operaci贸n as铆ncrona
    setTimeout(() => {
        resolver("隆Promesa resuelta!");
    }, 1000);
});

miPromesa
    .then(resultado => {
        console.log(resultado);
    })
    .catch(error => {
        console.error(error);
    })
    .finally(() => {
        console.log("Esto se ejecutar谩 sin importar el resultado de la promesa.");
    });


En este ejemplo, el bloque de c贸digo dentro de finally se ejecutar谩 despu茅s de que la promesa miPromesa se resuelva o rechace, lo que garantiza que ciertas tareas de limpieza o acciones finales se realicen, independientemente del resultado de la promesa.


M谩s ejemplos:


Ejemplo 1:

Imagina que est谩s haciendo un trato con alguien, pero no est谩s seguro de si el trato funcionar谩 o no. En este caso, est谩s usando una 鈥減romesa鈥. Ahora, piensa en el bloque finally como si fuera un paso que siempre debes hacer, sin importar si el trato funcion贸 o no.

Por ejemplo, imagina que haces un trato con un amigo para encontrarse en un parque a una hora espec铆fica. Pase lo que pase, al final, quieres asegurarte de que tu amigo sepa que llegaste al parque, incluso si llegaste tarde o si no pudiste llegar. En t茅rminos de programaci贸n, usar铆as finally para asegurarte de que algo suceda sin importar si el trato (la promesa) fue exitoso o no.

As铆 que, en el c贸digo:

const miPromesa = new Promise((resolver, rechazar) => {
    // Imagina que aqu铆 hay algo que toma un tiempo, como llegar al parque
    // Puede ser exitoso (resolver) o fallar (rechazar)
});

miPromesa
    .then(resultado => {
        // Esto es como decir "隆Llegu茅 al parque a tiempo!"
    })
    .catch(error => {
        // Esto es como decir "No pude llegar al parque"
    })
    .finally(() => {
        // Esto es como decir "Siempre quiero decirle a mi amigo que llegu茅, sin importar qu茅"
    });


En este ejemplo, el c贸digo dentro de finally siempre se ejecutar谩, sin importar si la promesa fue exitosa o fall贸. Es una forma 煤til de asegurarte de que se realice una acci贸n final, como contarle a tu amigo que llegaste al parque, sin importar lo que pase con el trato en s铆.


Ejemplo 2:

Aqu铆 tienes otro ejemplo usando una met谩fora diferente:

Imagina que est谩s cocinando algo en la cocina. Tienes una tarea importante al final: asegurarte de limpiar y ordenar la cocina, sin importar si la comida result贸 deliciosa o si algo sali贸 mal en la receta. En t茅rminos de programaci贸n, podr铆amos usar finally para representar esta tarea final que siempre se realiza.

const cocinarComida = () => {
    return new Promise((resolver, rechazar) => {
        // Aqu铆 cocinar铆amos algo, puede salir bien o mal
        const resultado = Math.random() < 0.5; // Simulamos 茅xito o fracaso

        if (resultado) {
            resolver("隆Comida deliciosa!");
        } else {
            rechazar("Algo sali贸 mal en la cocina");
        }
    });
};

cocinarComida()
    .then(resultado => {
        console.log(resultado);
    })
    .catch(error => {
        console.error(error);
    })
    .finally(() => {
        console.log("Limpio y ordenado, 隆siempre!");
    });


En este ejemplo, el bloque de c贸digo dentro de finally se ejecutar谩 sin importar si la comida result贸 deliciosa o si hubo un problema en la cocina. Es como decir que siempre quieres asegurarte de dejar la cocina en buen estado, independientemente del resultado de la preparaci贸n de la comida.

Espero sea de utilidad. 馃懆鈥嶐煉

Aprend铆 este m茅todo de finally a las malas en la empresa que trabajo como Frontend y, es que deb铆a colocar una animaci贸n de 鈥榗argando鈥 mientras la API hac铆a el proceso de traer la data y, fue justamente con el finally y un switch de clases que pude lograr esa tarea :3

Para mejorar un poco el codigo explicado y tomando referencias de MDN podemos formatear el codigo de la siguiente forma, e agregado comentarios para que de forma mas clara podamos notar los outputs de cada impresi贸n por consola

// Agregue un asterisco despu茅s de la function palabra clave para marcar una funci贸n como generadora.
function* anotherGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

const other = anotherGenerator();
// El metodo next()regresa un objeto con las propiedades doney value. Tambi茅n puedes pasar un par谩metro al m茅todo next para enviar un valor al generador.
console.log(other.next().value);
console.log(other.next().value);
console.log(other.next()); // Esto nos devuelve un Objecto con dos propiedades:

// Es verdadero si el iterador ya llego al final de la secuencia. En este caso valor, defina opcionalmente el valor de retorno del iterador.

// Es falso si el iterador puede dar un siguiente valor en la secuencia. Es equivalente a no definir la propiedad done.

//value => cualquier valor Javascript regresado por el iterador. Este puede ser omitido si done es verdadero.

console.log(other.next());
console.log('Hello!');
/*
1
2
{ value: 3, done: false }
{ value: undefined, done: true }
Hello!
*/

ya me estoy confundiendo en esta parte creo que va fallando la explicacion

En cada clase utiliza expresiones o terminos de js que no se han explicado en cursos anteriores, o por lo menos si seguimos unas de sus rutas definidas. Dejo un aporte para quien se haya fijado y no entendiese que ocurria.

yield await Promise.resolve(1); /* No utiliza new Promise .... */

/* Porque resolve() es un m茅todo estatico de la clase Promise y se declaran as铆: */

class Clase{
	static metodoEstatico() {
    		//...
  	}
}

La verdad me confundi贸 un poco. Sin embargo, es importante apoyarse de fuentes externas.

Ejemplo de c贸mo se podr铆an utilizar los generadores as铆ncronos en un escenario relacionado con un gimnasio, donde se obtienen los registros de asistencia de los miembros de manera as铆ncrona:

// Simulaci贸n de registros de asistencia en un gimnasio
const attendanceRecords = [
  { memberId: 1, date: '2023-05-10' },
  { memberId: 2, date: '2023-05-11' },
  { memberId: 3, date: '2023-05-12' },
  { memberId: 4, date: '2023-05-13' },
  { memberId: 5, date: '2023-05-14' }
];

async function* getAttendanceRecords() {
  for (const record of attendanceRecords) {
    // Simular una operaci贸n as铆ncrona, como obtener los datos del miembro desde una base de datos
    const memberData = await fetchMemberData(record.memberId);

    // Agregar los datos del miembro al registro de asistencia
    const attendanceRecordWithMemberData = {
      ...record,
      memberData
    };

    yield attendanceRecordWithMemberData;
  }
}

async function fetchMemberData(memberId) {
  // Simular una solicitud as铆ncrona para obtener los datos del miembro
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ memberId, name: 'John Doe', age: 30, subscription: 'Gold' });
    }, 1000);
  });
}

async function displayAttendanceRecords() {
  const attendanceGenerator = getAttendanceRecords();

  for await (const record of attendanceGenerator) {
    console.log(record);
  }

  console.log('Proceso de obtenci贸n de registros de asistencia finalizado');
}

displayAttendanceRecords();

//**Output**
 {
  memberId: 1,
  date: '2023-05-10',
  memberData: { memberId: 1, name: 'John Doe', age: 30, subscription: 'Gold' }
}
{
  memberId: 2,
  date: '2023-05-11',
  memberData: { memberId: 2, name: 'John Doe', age: 30, subscription: 'Gold' }
}
{
  memberId: 3,
  date: '2023-05-12',
  memberData: { memberId: 3, name: 'John Doe', age: 30, subscription: 'Gold' }
}
{
  memberId: 4,
  date: '2023-05-13',
  memberData: { memberId: 4, name: 'John Doe', age: 30, subscription: 'Gold' }
}
{
  memberId: 5,
  date: '2023-05-14',
  memberData: { memberId: 5, name: 'John Doe', age: 30, subscription: 'Gold' }
}
Proceso de obtenci贸n de registros de asistencia finalizado

En este ejemplo, tenemos un array ficticio llamado attendanceRecords que contiene registros de asistencia de los miembros del gimnasio. La funci贸n generadora as铆ncrona getAttendanceRecords() se utiliza para obtener los registros de asistencia de manera as铆ncrona.

Dentro del bucle for鈥f de la funci贸n generadora, se recorren los registros de asistencia y se realiza una operaci贸n as铆ncrona ficticia para obtener los datos del miembro utilizando la funci贸n fetchMemberData(). Esta funci贸n simula una solicitud as铆ncrona para obtener los datos del miembro a partir de un memberId. En este caso, se utiliza setTimeout para simular una demora de 1 segundo antes de que se resuelva la promesa y se devuelvan los datos del miembro.

Luego, se agrega los datos del miembro obtenidos al registro de asistencia utilizando la sintaxis de objetos extendidos (鈥ecord) para crear una nueva objeto attendanceRecordWithMemberData que contiene tanto los datos del registro de asistencia como los datos del miembro.

El resultado de cada iteraci贸n del generador es un objeto que combina el registro de asistencia con los datos del miembro, y se muestra en la consola.

Finalmente, el proceso de obtenci贸n de registros de asistencia finaliza cuando se completa el recorrido del generador, y se muestra un mensaje de finalizaci贸n.

Algo interesante que deber铆as probar:

Mi resumen:

Lo de asincrono se pone un poco m谩s dif铆cil a mi punto de vista, pero con pr谩ctica lo lograr茅鈥igan as铆 compa帽eros que ya est谩n en la clase 23.

23/35 ES9: Promise.finally

En Es9 se agregaron el m茅todo finallu para promesas y los generadores as铆ncronos. El m茅todo finally permite ejecutar c贸digo despu茅s de que una promesa haya sido resuelta o rechazada, mientras que los generadores as铆ncronos combinan la sintaxis de generadores con promesas para permitir un mejor manejo de c贸digo as铆ncrono. Tambi茅n se puede utilizar el ciclo for await para iterar sobre elementos de un iterable de manera as铆ncrona.

Ejemplo:

// Ejemplo de m茅todo finally en promesas
promesa()
  .then(response => console.log(response)) // Promesa resuelta
  .catch(error => console.log(response)) // Promesa rechazada
  .finally(() => console.log("Finalizado")) // C贸digo final  

// Ejemplo de generadores as铆ncronos
async function* anotherGenerator() {
  yield await Promise.resolve(1)
  yield await Promise.resolve(2)
  yield await Promise.resolve(3)
}

const generador = anotherGenerator()
generador.next().then(respuesta => console.log(respuesta.value))
generador.next().then(respuesta => console.log(respuesta.value))
generador.next().then(respuesta => console.log(respuesta.value))

// Ejemplo de for await
async function forAwait() {
  const nombres = ["Alexa", "Oscar", "David"]
  for await (let valor of nombres) {
    console.log(valor)
  }
}

forAwait()

Ejemplo corregido del generador, con las promesas, pero sin el async-await:

function* anotherGenerator() {
yield Promise.resolve(1);
yield Promise.resolve(2);
yield Promise.resolve(3);
}

const other = anotherGenerator();
console.log(other.next().value)
console.log(other.next().value)
console.log(other.next().value)
console.log(鈥渉ello鈥);

Modifique el primer ejemplo que ponen en la secci贸n de recursos.

promesa()
    .then(response => console.log(response)) // Promesa resuelta
    .catch(error => console.log(error)) // Promesa rechazada
    .finally(() => console.log("Independientemente del estado final de la promesa, esto se tiene que hacer....")); // C贸digo final 

Cosas de la vida XD

async function* objectAsyncPromise(arr) {
  for await (let res of arr) {
    console.log(res, "promise");
  }
}
async function objectAsync(arr) {
  for await (let res of arr) {
    console.log(res, "async");
  }
}
const arrName = ["Chirly", "Daniela", "Marcela", "Tatiana"];
const namesAsyncPromise = objectAsyncPromise(arrName);
namesAsyncPromise.next().then((res) => res);
objectAsync(arrName);

Un peque帽o ejemplo XD

function* generatePromise() {
  yield Promise.resolve(1);
  yield Promise.resolve(2);
  yield Promise.resolve(3);
}
const generatePromise = generatePromise();
async function* generateASync() {
  yield await Promise.resolve(1);
  yield await Promise.resolve(2);
  yield await Promise.resolve(3);
}
const asyncGenerate = generateASync();

generatePromise.next().value.then((res) => console.log(res, "promise"));
asyncGenerate.next().then((res) => console.log(res.value, "async"));