Playground - Resuelve el callback hell usando async/await

30 días de JavaScript

¡Te damos la bienvenida a este reto!

¡Bienvenido al mundo de JavaScript!

Día 1

Variables, funciones y sintaxis básica

Tipos de datos

Playground - Retorna el tipo

Tipos de datos - pt 2

Día 2

Operadores

Hoisting y coerción

Playground - Calcula la propina

Alcance de las variables

Día 3

Condicionales

Playground - Calcula años bisiestos

Switch

Playground - Obten información de mascotas según su tipo

Ciclos

Playground - Dibuja un triangulo

Día 4

Arrays

Playground - Encuentra al michi mas famoso

Objetos

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

Playground - encuentra el palindromo más grande

Día 6

Reasignación y redeclaración

Modo estricto

Día 7

Debugging y manejo de errores

Programación funcional

Quiz: Día 7

Día 8

Closures

Playground - Crea una calculadora con closures

Higher order functions

Playground - Crea tu propio método map

Día 9

ECMAScript

TC39

Quiz: Día 9

Día 10 - Checkpoint

ES6

ES7

Playground - Task planner

Día 11

Asincronismo

Playground - Promesas

Manejando el asincronismo

Playground - Resuelve el callback hell usando promesas

Playground - Resuelve el callback hell usando async/await

Día 12

Arrays a profundidad

Métodos de arrays: Every, Find y findIndex

Playground - Válida el formulario

Día 13

Métodos de arrays: Includes, Join y concat

Playground - agrupa los productos

Métodos de arrays: Flat y FlatMap

Playground - Encuentra la ubicación del valor buscado

Día 14

Mutable functions

Playground - Modifica una lista de compras

Métodos de arrays: sort

Playground - Ordena los productos

Día 15 - Checkpoint

Playground - Sistema de reservaciones de un hotel

Día 16

Programación orientada a objetos en JavaScript

Objetos literales

Playground - Congela el objeto recursivamente

Día 17

Prototipos en JavaScript

Playground - Modifica el prototype de los arrays

Playground - Crea un auto usando clases

Día 18

Abstracción en JavaScript

Playground - Sistema de carrito de compras

Encapsulamiento en JavaScript

Playground - Encapsula datos de los usuarios

Día 19

Herencia en JavaScript

Playground - Jerarquía de animales

Polimorfismo en JavaScript

Playground - Sistema de pagos

Día 20 - Checkpoint

Playground - Agenda de vuelos

Día 21

Patrones de diseño

Sinlgeton y Factory pattern en JavaScript

Playground - Implementa singleton en un chat

Día 22

Adapter y Decorator pattern en JavaScript

Playground - Personaliza productos de una tienda

Builder y Protype pattern en JavaScript

Playground - Mejora el código usando builder pattern

Día 23

Facade y proxy pattern en JavaScript

Playground - Proxy en servicio de mensajería

Chain of responsability y Observer pattern en JavaScript

Playground - Implementación de Observador en Newsletter

Día 24 - Checkpoint

Playground - Crea un task manager con patrones de diseño

Día 25

Estructuras de datos en JavaScript

Playground - Crea tu propia implementación de un array

Hash tables en JavaScript

Playground - Implementación de una HashTable para Contactos

Día 26

Set en JavaScript

Playground - Remueve duplicados de una lista

Maps en JavaScript

Playground - Crea un organizador de tareas

Día 27

Singly Linked List en JavaScript

Playground - Agrega métodos a la singly linked list

Playground - Implementación de una singly linked list

Día 28

Stacks en JavaScript

Playground - Crea un stack para una playlist

Día 29

Queues en JavaScript

Playground - Crea una cola de emails

Día 30

¡Lo lograste!

Live Class

30 días de JS con Juan DC

30 días de JS con Nicobytes

30 días de JS con GNDX

30 días de JS con LeoCode

30 días de JS con Teffcode

Sesión: Cierre de los 30 días de JavaScript

You don't have access to this class

Keep learning! Join and start boosting your career

If you already have an account,

Contributions 38

Questions 1

Sort by:

Want to see more contributions, questions and answers from the community?

Pablo Pincay Alvarez

2 years ago

.
. ----------------------------------
. ESCUDO ANTI SPOILER
. ----------------------------------
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  return [await doTask1(), await doTask2(), await doTask3()]
}

y en tasks,js es el mismo que el anterior

Santiago Quintero

2 years ago

MI solución:

export async function runCode() {
  const strings = [];

  strings.push(await doTask1());
  strings.push(await doTask2());
  strings.push(await doTask3());

  return strings;
}

task.js

export async function doTask1(callback) {
  return new Promise((resolve, reject) => {

    window.setTimeout(() => resolve('Task 1'), 300)
  })
}

export async function doTask2(callback) {
  return new Promise((resolve, reject) => {

    window.setTimeout(() => resolve('Task 2'), 300)
  })
}

export async function doTask3(callback) {
  return new Promise((resolve, reject) => {

    window.setTimeout(() => resolve('Task 3'), 300)
  })
}

Agustin Choque Veliz

2 years ago

Sí que tienen razón, este modo de trabajar es mas legible.
las doTasks no cambiaron en relación al anterior reto.

<export function doTask1() {
    return new Promise(resolve => {
        window.setTimeout(() => resolve('Task 1'), 300);
    });
}
export function doTask2() {
    return new Promise(resolve => {
        window.setTimeout(() => resolve('Task 2'), 300);
    });
}
export function doTask3() {
    return new Promise(resolve => {
        window.setTimeout(() => resolve('Task 3'), 300);
    });
}>

Y este el código del runCode(), mucho mas legible y corto.

<import { doTask1, doTask2, doTask3 } from './tasks';
exportasync function runCode() {
    const strings = [];
    const rta1 = await doTask1();
    strings.push(rta1);
    const rta2 = await doTask2();
    strings.push(rta2);
    const rta3 = await doTask3();
    strings.push(rta3);
    return strings;
}>

Pablo Perez

2 years ago

Mi solución usando Promise.allSettled:

// exercise.js
import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  return Promise.allSettled([doTask1(), doTask2(), doTask3()])
    .then(listOfObjects => listOfObjects.map(element => element.value))
    
}

// tasks.js
export async function doTask1() {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => resolve('Task 1'), 300);
  })
}
export async function doTask2() {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => resolve('Task 2'), 300);  
  })
}

export async function doTask3() {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => resolve('Task 3'), 300);
  })
}

David Ochoa

2 years ago

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️

Callback hell usando async-await

tasks.js

function doTask1() {
  return new Promise((resolve) => {
    setTimeout(() => resolve("Task 1"), 300);
  });
}

function doTask2() {
  return new Promise((resolve) => {
    setTimeout(() => resolve("Task 2"), 300);
  });
}

function doTask3() {
  return new Promise((resolve) => {
    setTimeout(() => resolve("Task 3"), 300);
  });
}

exercise.js

export async function runCode() {
  const strings = [];
  const res1 = await doTask1();
  const res2 = await doTask2();
  const res3 = await doTask3();

  strings.push(res1);
  strings.push(res2);
  strings.push(res3);

  return strings;
}

Daniel Sebastián Rodríguez

2 years ago

Aporto mi solución

Spoiler

exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [await doTask1(), await doTask2(), await doTask3()];
    return await strings;
}

tasks.js

export function doTask1() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 1'), 300);
  })
}

export function doTask2() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 2'), 300);
  })
}

export function doTask3() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 3'), 300);
  })
}

Gustavo Alonso Aguilar Acuña

2 years ago

Lo logré! sin duda es mas intuitivo que el .then
.
.
.
.
.
.
.
.
.
…

import { doTask1, doTask2, doTask3 } from './tasks';
export async function runCode() {  //le agrego el async porque ellos usan await
  const strings = [];

  async function paso() {   //creo una funcion para que sea asincronica
    const string1 = await doTask1();  //espero que se haga y push
    strings.push(string1);

    strings.push(await doTask2()); //push pero cuando ya se hace

    strings.push(await doTask3());
    return strings;   //la funcion me retorna el string
  }
  let result = await paso();  //para darle valor a result se ejecuta paso()
  return result; //se retorna ese resultado
}

task.js

export async function doTask1() {
return new Promise((resolve) => {
window.setTimeout(() => resolve(‘Task 1’), 300);
})

}

export async function doTask2() {
return new Promise((resolve) => {
window.setTimeout(() => resolve(‘Task 2’), 300);
})

}

export async function doTask3() {
return new Promise((resolve) => {
window.setTimeout(() => resolve(‘Task 3’), 300);
})
}

Andrés Soret Chacin

3 months ago

## My solution 👇 **exercise.js:** ```js import { doTask1, doTask2, doTask3 } from './tasks'; export async function runCode() { const rta1 = await doTask1(); const rta2 = await doTask2(); const rta3 = await doTask3(); const strings = [rta1, rta2, rta3]; return strings; } ```

Ricardo Alfonso Chavez Vilcapoma

2 years ago

HEY!!!

NO BAJES NO BAJES…SPOILER ALERT!!!

task.js

export function doTask1() {
  return new Promise(resolve => {
    window.setTimeout(() => resolve('Task 1'), 300);
  })
}

export function doTask2() {
  return new Promise(resolve => {
    window.setTimeout(() => resolve('Task 2'), 300);
  })
}

export function doTask3() {
  return new Promise(resolve => {
    window.setTimeout(() => resolve('Task 3'), 300);
  })
}

exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];
  /* return new Promise((resolve) => {
    doTask1((rta1) => {
      strings.push(rta1);
      doTask2((rta2) => {
        strings.push(rta2);
        doTask3((rta3) => {
          strings.push(rta3);
          resolve(strings);
        })
      })
    })
  }) */
  const task1 = await doTask1();
  const task2 = await doTask2();
  const task3 = await doTask3();

  strings.push(task1);
  strings.push(task2);
  strings.push(task3);

  return strings;
}

runCode();

Julio Bastidas

2 years ago

tasks.js

export async function doTask1() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 1'), 300);
  });
}

export async  function doTask2() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 2'), 300);
  });
}

export async function doTask3() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 3'), 300);
  });
}

exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];
  strings.push(await doTask1());
  strings.push(await doTask2());
  strings.push(await doTask3());
  return strings
}

Manuel Alexander Montañez Gordillo

2 years ago

exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {

  const result1 = doTask1();
  const result2 = doTask2();
  const result3 = doTask3();

  const [rta1, rta2, rta3] = await promise.all([result1, result2, result3]);

  strings.push(rta1);
  strings.push(rta2);
  strings.push(rta3);

  return strings;
}

task-ks

<export function doTask1() {
  return new Promise(resolve => {
    window.setTimeout(() => resolve('Task 1'), 300);
  });
}
export function doTask2() {
  return new Promise(resolve => {
    window.setTimeout(() => resolve('Task 2'), 300);
  });
}
export function doTask3() {
  return new Promise(resolve => {
    window.setTimeout(() => resolve('Task 3'), 300);
  });
}>

Juan Camilo Noreña López

2 years ago

Acá dejo mi solución:
Pero primero el antispoiler
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

task.js

export function doTask1() {
  return new Promise((resolve) =>
    window.setTimeout(() =>
      resolve('Task 1'), 300))
}

export function doTask2() {
  return new Promise((resolve) =>
    window.setTimeout(() =>
      resolve('Task 2'), 300))
}

export function doTask3() {
  return new Promise((resolve) =>
    window.setTimeout(() =>
      resolve('Task 3'), 300))
}

exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];
  const rta1 = await doTask1();
  strings.push(rta1)
  const rta2 = await doTask2();
  strings.push(rta2)
  const rta3 = await doTask3();
  strings.push(rta3)
  return strings;

}

Carina Payleman

2 years ago

.
.
.
.
.
.

exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
    const strings = [];
    strings.push(await doTask1());
    strings.push(await doTask2());
    strings.push(await doTask3());
    return strings;
}

tasks.js

export async function doTask1() {
    return new Promise((resolve) => {
        window.setTimeout(() => resolve('Task 1'), 300);
    })
}
export async function doTask2() {
    return new Promise((resolve) => {
        window.setTimeout(() => resolve('Task 2'), 300);
    })
}  
export async function doTask3() {
    return new Promise((resolve) => {
        window.setTimeout(() => resolve('Task 3'), 300);
    })
}

Alexis Corrales

2 years ago

part 1

export function doTask1() {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve('Task 1');
    }, 300);
  });
}

export function doTask2() {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve('Task 2');
    }, 300);
  });
}

export function doTask3() {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve('Task 3');
    }, 300);
  });
}

part 2

export async function runCode() {
  const strings = [];
  try {
    strings.push(await doTask1());
    strings.push(await doTask2());
    strings.push(await doTask3());
    return strings;
  } catch (error) {
    console.error(error);
  }
}

Christian Ricardo Conchari Cabrera

2 years ago

Comparto mi solución:

.
.
.
.
.

tasks.js

export async function doTask1() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 1'), 300);  
  });
}

export async function doTask2() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 2'), 300);
  });
}

export async function doTask3() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 3'), 300);
  });
}

exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];
  strings.push(await doTask1());
  strings.push(await doTask2());
  strings.push(await doTask3());
  return strings;
}

pariksit7

2 years ago

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];
  strings.push(await doTask1());
  strings.push(await doTask2());
  strings.push(await doTask3());
  return strings;
}

Alejandro Anaya

2 years ago

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto:

Archivo: exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';
export async function runCode() {
    const strings = [];
  
    strings.push(await doTask1());
    strings.push(await doTask2());
    strings.push(await doTask3());
  
    return strings;
  }

Archivo: tasks.js

  // File: tasks.js
  export async function doTask1(callback) {
    return new Promise((resolve, reject) => {
  
      window.setTimeout(() => resolve('Task 1'), 300)
    })
  }
  
  export async function doTask2(callback) {
    return new Promise((resolve, reject) => {
  
      window.setTimeout(() => resolve('Task 2'), 300)
    })
  }
  
  export async function doTask3(callback) {
    return new Promise((resolve, reject) => {
  
      window.setTimeout(() => resolve('Task 3'), 300)
    })
  }

Julian Roa Villamil

2 years ago

mi solución:
🫡
🫡
🫡
🫡
🫡
🫡
🫡
🫡
🫡

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];

  strings.push(await doTask1());
  strings.push(await doTask2());
  strings.push(await doTask3());

  return strings;
}

export function doTask1() {
  return new Promise(resolve => {
    window.setTimeout(() => resolve('Task 1'), 300);
  })
  //window.setTimeout(() => callback('Task 1'), 300);
}

export function doTask2(callback) {
  return new Promise(resolve => {
    window.setTimeout(() => resolve('Task 2'), 300);
  })
  //window.setTimeout(() => callback('Task 2'), 300);
}

export function doTask3(callback) {
  return new Promise(resolve => {
    window.setTimeout(() => resolve('Task 3'), 300);
  })
  //window.setTimeout(() => callback('Task 3'), 300);
}

Hiver Tapia

2 years ago

¿Qué problema habría de ésta forma?

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  return await Promise.all([doTask1(), doTask2(), doTask3()]);
}

el archivo task.js

 export  function doTask1() {
    return new Promise((resolve)=>{
    setTimeout(() => resolve('Task 1'), 300);
  }) 
  }
  
 export   function doTask2() {
    return new Promise((resolve)=>{
      setTimeout(() => resolve('Task 2'), 300);
    })
  }
  
 export   function doTask3() {
    return new Promise((resolve)=>{
      setTimeout(() => resolve('Task 3'), 300);
    })
  }

Daniel André Amaya López

2 years ago

👾 Mi solución

🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧

tasks.js

export function doTask1() {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => resolve("Task 1"), 300);
  });
}

export function doTask2() {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => resolve("Task 2"), 300);
  });
}

export function doTask3() {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => resolve("Task 3"), 300);
  });
}

exercise.js

export async function runCode() {
  return [await doTask1(), await doTask2(), await doTask3()]
}

sgb004

2 years ago

import { doTask1, doTask2, doTask3 } from './tasks';

export const runCode = async () => [
  await doTask1(),
  await doTask2(),
  await doTask3()
];

export const doTask1 = async () => new Promise(resolve => window.setTimeout(() => resolve('Task 1'), 300));

export const doTask2 = async () => new Promise(resolve => window.setTimeout(() => resolve('Task 2'), 300));

export const doTask3 = async () => new Promise(resolve => window.setTimeout(() => resolve('Task 3'), 300));

Angel Javier Sanchez Tenjo

2 years ago

Hola La Solución del Reto en :
🔟
9️⃣
8️⃣
7️⃣
6️⃣
5️⃣
4️⃣
3️⃣
2️⃣
1️⃣
0️⃣

exercise.js

import { doTask1, doTask2, doTask3 } from "./tasks";

export function runCode() {
  const strings = [];
  return new Promise(async (resolve) => {
    let rta = await doTask1();
    strings.push(rta);
    rta = await doTask2();
    strings.push(rta);
    rta = await doTask3();
    strings.push(rta);

    resolve(strings);
  });
}

tasks.js

export function doTask1() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve("Task 1"), 300);
  });
}

export function doTask2() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve("Task 2"), 300);
  });
}

export function doTask3() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve("Task 3"), 300);
  });
}

willmar fernando romero marin

2 years ago

éxito total estas dinámicas. se puede decir que concepto aprendido

metsuke

2 years ago

Después de entender este ejercicio, no acabo de comprender porque mi cerebro tiene tanto problema para procesar el funcionamiento de algo tan sencillo ¿quizá resistencia por años de programación en la que las funciones no volaban en forma de variables hacia todas partes? , sigamos! 😃

Jose Carlos Machado

2 years ago

Bueno, no se si fue por vagancia, pero sólo modifique el código anterior y lo adapté para async/await… espero que les guste… 😃

Exercise.js


async function runCode() {
  const strings = [];

  return await new Promise((resolve) => {
    doTask1(arg => strings.push(arg))
      .then(data => doTask2(arg2 => strings.push(arg2)))
      .then(data => doTask3(arg3 => strings.push(arg3)))
      .then(data => resolve(strings));
    ;

  })
}

Tasks.js

async function doTask1(callback) {

  return await new Promise((resolve) => {
    window.setTimeout(() => { resolve(callback('Task 1')) }, 300);
  });
}

export async function doTask2(callback) {
  return await new Promise((resolve) => {
    window.setTimeout(() => { resolve(callback('Task 2')) }, 300);
  });
}

export async function doTask3(callback) {
  return await new Promise((resolve) => {
    window.setTimeout(() => { resolve(callback('Task 3')) }, 300);
  });
}

Elias Rayas Gonzalez

2 years ago

Solución

async function runCode() {
	const strings = []
  const str1 = await doTask1()
  const str2 = await doTask2()
  const str3 = await doTask3()
  strings.push(str1)
  strings.push(str2)
  strings.push(str3)
  console.log(strings)
  return strings
}

Giovanny Contreras Muñoz

2 years ago

…
…
…
…
…
…
…
…
…
…
…
…
…
…
…

export function  runCode() {
  const strings = [];
  return new Promise( async (resolve) => {
    const rta1 = await doTask1((rta1) => rta1);
    const rta2 = await doTask2((rta2) => rta2);
    const rta3 = await doTask3((rta3) => rta3);
    strings.push(rta1, rta2, rta3);
    resolve(strings);
   
  })
}

Victor Ortiz

2 years ago

Otro mas y seguimos
.
.
.
.
.
.
.
.
.
.
.
.
.
exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];
  strings.push(await doTask1());
  strings.push(await doTask2());
  strings.push(await doTask3());
  return strings;
}

tasks.js

export async function doTask1() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 1'), 300);
  });
}

export async function doTask2() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 2'), 300);
  });
}

export async function doTask3() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 3'), 300);
  })
}

Diego Herrera Prado

2 years ago

Comparto mi solución
.
.
.
.
.
.
.
.
.
.
.
.

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];
  strings.push(...await Promise.all([doTask1(), doTask2(),doTask3()]))
  return strings;
}

Felipe Moreno

2 years ago

exercise.js

tasks.js

Osvaldo Martinez Guillen

2 years ago

Fue más sencillo que en el anterior

Se nota la ventaja de usar async/await

tasks.js

export async function doTask1() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 1'), 300);
  });
}

export async function doTask2() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 2'), 300);
  });
}

export function doTask3() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 3'), 300);
  });
}

exersice.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];
  strings.push(await doTask1());
  strings.push(await doTask2());
  strings.push(await doTask3());
  return strings;
}

JAIME EDUARDO DIAZ TOBON

2 years ago

MI SOLUCION 💪
Definitivamente es mucho mas legible
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
tasks.js

export async function doTask1(callback) {
  return new Promise((resolve, reject) => 
    window.setTimeout(() => resolve('Task 1'), 300)
  );
}

export async function doTask2(callback) {
  return new Promise((resolve, reject) =>
    window.setTimeout(() => resolve('Task 2'), 300)
  );
}

export async function doTask3(callback) {
  return new Promise((resolve, reject) =>
    window.setTimeout(() => resolve('Task 3'), 300)
  );
}

exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];
  strings.push(await doTask1());
  strings.push(await doTask2());
  strings.push(await doTask3());
  return strings;
}

Rony Tito Ventura Ramos

2 years ago

Mi solución compañeros:
.
.
.
.
.
.
.
.
.

import { doTask1, doTask2, doTask3 } from './tasks';

export function runCode() {
  const strings = [];
  return new Promise(async (resolve) => {
    try {  
      strings.push(await doTask1())
      strings.push(await doTask2())
      strings.push(await doTask3())
      resolve(strings)
      
    } catch (error) {
      console.log(error.message)
    }
  })
}

y por último el archivo tas.js

export function doTask1() {
  return new Promise(resolve => {
    window.setTimeout(resolve('Task 1'), 400);
  })
}

export function doTask2() {
  return new Promise((resolve) => {
    window.setTimeout(resolve('Task 2'), 600);
  })
}

export function doTask3() {
  return new Promise((resolve) => {
    window.setTimeout(resolve('Task 3'), 300);
  })
}

Harold Zurita Simon

2 years ago

Solución… 😄
.
Para resolver el reto, el archivo tasks.js será el mismo que el del anterior.
.
Mientras que en exercise.js añadimos async a la función runCode(), creamos un array de tareas ‘strings’ y mediante await obtenemos las tareas y las añadimos al array. Retornamos ‘strings’.
.
exercise.js:
.

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];

  strings.push(await doTask1());
  strings.push(await doTask2());
  strings.push(await doTask3());

  return strings;

}

.
tasks.js:
.

export function doTask1() {
  return new Promise((resolve) => {
    window.setTimeout(() => {
      resolve('Task 1');
    }, 300);
  });
}

export function doTask2() {
  return new Promise((resolve) => {
    window.setTimeout(() => {
      resolve('Task 2');
    }, 300);
  });
}

export function doTask3() {
  return new Promise((resolve) => {
    window.setTimeout(() => {
      resolve('Task 3');
    }, 300);
  });
}

Ivan Pérez Arencibia

2 years ago

Solución

File exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];

  strings.push(await doTask1());
  strings.push(await doTask2());
  strings.push(await doTask3());
  
  return strings;
}

File tasks.js

export async function doTask1() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 1'), 300);
  });
}

export async function doTask2() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 2'), 300);
  });
}

export async function doTask3() {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve('Task 3'), 300);
  });
}

Ruben Gallegos Hernandez

2 years ago

Adjunto mi respuesta.
En el archivo exercise.js usando await, ya no se tiene que usar el callback then, así podemos obtener el resultado de las promesas en la misma línea porque pausa la ejecución y obtiene el resultado de la promesa directamente.

import { doTask1, doTask2, doTask3 } from './tasks';

export  function runCode() {
  const strings = [];

  async function returnTasks() {
    let str1 = await doTask1();
    let str2 = await doTask2();
    let str3 = await doTask3();
    return [str1, str2, str3];
  }
return returnTasks();
}

En el archivo tasks es lo mismo que en el ejercicio pasado que fue cambiar los callbacks por promesas.

Daniel Romao

2 years ago

Menos mal que pusieron async/await

Solucion:
.
.
.
.
.
.
.
.
.
.
.
.
.
exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];
  let rta1 = await doTask1();
  let rta2 = await doTask2();
  let rta3 = await doTask3();

  strings.push(rta1, rta2, rta3);
  return strings;
}

task.js

export function doTask1() {
  return new Promise((resolve) => window.setTimeout(() => resolve('Task 1'), 300));
}

export function doTask2() {
  return new Promise((resolve) => window.setTimeout(() => resolve('Task 2'), 300));
}

export function doTask3() {
  return new Promise((resolve) => window.setTimeout(() => resolve('Task 3'), 300));
}

Abril Darynka Tapia Sosa

2 years ago

Hola, dejo mi solucion
Caminito anti spoilers
🚗
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Llegamos 📍

Task.js

export function doTask1(callback) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve('Task 1')
    }, 300)
  })
}

export function doTask2(callback) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve('Task 2')
    }, 300)
  })
}

export function doTask3(callback) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve('Task 3')
    }, 300)
  })
}

exercise.js

import { doTask1, doTask2, doTask3 } from './tasks';

export async function runCode() {
  const strings = [];
  let result1 = await doTask1();
  strings.push(result1);
  let result2 = await doTask2();
  strings.push(result2);
  let result3 = await doTask3();
  strings.push(result3);
  return strings
}