隆Te damos la bienvenida a este reto!

1

隆Bienvenido al mundo de JavaScript!

D铆a 1

2

Variables, funciones y sintaxis b谩sica

3

Tipos de datos

4

Playground - Retorna el tipo

5

Tipos de datos - pt 2

D铆a 2

6

Operadores

7

Hoisting y coerci贸n

8

Playground - Calcula la propina

9

Alcance de las variables

D铆a 3

10

Condicionales

11

Playground - Calcula a帽os bisiestos

12

Switch

13

Playground - Obten informaci贸n de mascotas seg煤n su tipo

14

Ciclos

15

Playground - Dibuja un triangulo

D铆a 4

16

Arrays

17

Playground - Encuentra al michi mas famoso

18

Objetos

19

Playground - Obten el promedio de los estudiantes

D铆a 5 - Checkpoint

20

Playground - encuentra el palindromo m谩s grande

D铆a 6

21

Reasignaci贸n y redeclaraci贸n

22

Modo estricto

D铆a 7

23

Debugging y manejo de errores

24

Programaci贸n funcional

Quiz: D铆a 7

D铆a 8

25

Closures

26

Playground - Crea una calculadora con closures

27

Higher order functions

28

Playground - Crea tu propio m茅todo map

D铆a 9

29

ECMAScript

30

TC39

Quiz: D铆a 9

D铆a 10 - Checkpoint

31

ES6

32

ES7

33

Playground - Task planner

D铆a 11

34

Asincronismo

35

Playground - Promesas

36

Manejando el asincronismo

37

Playground - Resuelve el callback hell usando promesas

38

Playground - Resuelve el callback hell usando async/await

D铆a 12

39

Arrays a profundidad

40

M茅todos de arrays: Every, Find y findIndex

41

Playground - V谩lida el formulario

D铆a 13

42

M茅todos de arrays: Includes, Join y concat

43

Playground - agrupa los productos

44

M茅todos de arrays: Flat y FlatMap

45

Playground - Encuentra la ubicaci贸n del valor buscado

D铆a 14

46

Mutable functions

47

Playground - Modifica una lista de compras

48

M茅todos de arrays: sort

49

Playground - Ordena los productos

D铆a 15 - Checkpoint

50

Playground - Sistema de reservaciones de un hotel

D铆a 16

51

Programaci贸n orientada a objetos en JavaScript

52

Objetos literales

53

Playground - Congela el objeto recursivamente

D铆a 17

54

Prototipos en JavaScript

55

Playground - Modifica el prototype de los arrays

56

Playground - Crea un auto usando clases

D铆a 18

57

Abstracci贸n en JavaScript

58

Playground - Sistema de carrito de compras

59

Encapsulamiento en JavaScript

60

Playground - Encapsula datos de los usuarios

D铆a 19

61

Herencia en JavaScript

62

Playground - Jerarqu铆a de animales

63

Polimorfismo en JavaScript

64

Playground - Sistema de pagos

D铆a 20 - Checkpoint

65

Playground - Agenda de vuelos

D铆a 21

66

Patrones de dise帽o

67

Sinlgeton y Factory pattern en JavaScript

68

Playground - Implementa singleton en un chat

D铆a 22

69

Adapter y Decorator pattern en JavaScript

70

Playground - Personaliza productos de una tienda

71

Builder y Protype pattern en JavaScript

72

Playground - Mejora el c贸digo usando builder pattern

D铆a 23

73

Facade y proxy pattern en JavaScript

74

Playground - Proxy en servicio de mensajer铆a

75

Chain of responsability y Observer pattern en JavaScript

76

Playground - Implementaci贸n de Observador en Newsletter

D铆a 24 - Checkpoint

77

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

D铆a 25

78

Estructuras de datos en JavaScript

79

Playground - Crea tu propia implementaci贸n de un array

80

Hash tables en JavaScript

81

Playground - Implementaci贸n de una HashTable para Contactos

D铆a 26

82

Set en JavaScript

83

Playground - Remueve duplicados de una lista

84

Maps en JavaScript

85

Playground - Crea un organizador de tareas

D铆a 27

86

Singly Linked List en JavaScript

87

Playground - Agrega m茅todos a la singly linked list

88

Playground - Implementaci贸n de una singly linked list

D铆a 28

89

Stacks en JavaScript

90

Playground - Crea un stack para una playlist

D铆a 29

91

Queues en JavaScript

92

Playground - Crea una cola de emails

D铆a 30

93

隆Lo lograste!

Live Class

94

30 d铆as de JS con Juan DC

95

30 d铆as de JS con Nicobytes

96

30 d铆as de JS con GNDX

97

30 d铆as de JS con LeoCode

98

30 d铆as de JS con Teffcode

99

Sesi贸n: Cierre de los 30 d铆as de JavaScript

No tienes acceso a esta clase

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

Playground - Resuelve el callback hell usando async/await

38/99

Aportes 38

Preguntas 1

Ordenar por:

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

.
. ----------------------------------
. 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

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)
  })
}

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;
}> 

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);
  })
}

Aporto mi soluci贸n

Spoiler

Spoiler

Spoiler

Spoiler

Spoiler

Spoiler

Spoiler

Spoiler

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);
  })
}

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(鈥楾ask 1鈥), 300);
})

}

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

}

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

HEY!!!

NO BAJES NO BAJES鈥POILER 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();

Soluci贸n! 馃槃

馃洝锔忦煕★笍馃洝锔廍scudo 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;
}

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
}

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);
  });
}> 

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;

}


.
.
.
.
.
.

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);
    })
}

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);
  }
}

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;
}

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;
}

馃洝锔忦煕★笍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)
    })
  }

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);
}

驴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);
    })
  }

馃懢 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()]
}
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));

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);
  });
}

茅xito total estas din谩micas. se puede decir que concepto aprendido

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! 馃槂

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);
  });
}

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
}















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);
   
  })
}

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);
  })
}

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;
}

exercise.js

tasks.js

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;
}

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;
}

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);
  })
}

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 鈥榮trings鈥 y mediante await obtenemos las tareas y las a帽adimos al array. Retornamos 鈥榮trings鈥.
.
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);
  });
}

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);
  });
}

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.

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));
}

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
}
undefined