Playground: Crea una función de delay que soporte asincronismo

Dejó el código abajo para el que lo necesite, intenta resolverlo primero antes de verlo

**
*
*
*
*
*
*
*
*
*
*

export function delay(time, message) {
   return new Promise((resolve, reject) =>{
       window.setTimeout(() =>{
        resolve (message);
       }, time);
       
    });
}

Hola,
Yo incluí una pequeña verificación de que el tiempo recibido no sea negativo 😉
**
*
*
*
*
*
*
*
*
*
*

export function delay(time, message) {
  const pro = new Promise(function (resolve, reject) {
    if (time >= 0) {
      window.setTimeout(() => {
        resolve(message)
      }, time)
    } else {
      reject("Time cannot be negative")
    }
  })
  return pro
}

Fue complejo entender que la dentro del setime out iba una funcion que contenia el rejected y no el llamado al rejected. Mi solucion:

export function delay(time, message) {
    return new Promise((resuelve, rechaza) => {
      if (true) {
        window.setTimeout(() => resuelve(message), time)
	/*así no: window.setTimeout(resuelve(message), time)*/
      }
    })
  }

Estos ejercicios me parecen extraños porque en una clase se ve algo y el siguiente ejercicio hay que resolverlo con algo que no se ha visto. Siendo muy jr en JS no se me habría ocurrido la respuesta ni en un año

No me carga el playground… 😦
Asi lo veo en mi navegador…

No entiendo la consola de ejercicios me marca error y me saca como se lo hice en Firefox
 

function funcionTiempo(tiempo, msn){
  
return new Promise((resolve, reject) => {
    if (tiempo == 2000) setTimeout(resolve,tiempo,msn);
    else reject('__ERROR__');});};


const fTiempo = funcionTiempo(2000, 'mensaje');

fTiempo.then(resultado =>{
  console.log(resultado);}).catch( error => {
  					console.log(error);});

Hola Team Platzi, se que están en versión de pruebas, pero mi solución es la misma pero diferente método así como las hemos utilizado en los cursos, pero la desarrollo y me sale error. por que hay que utilizar arrow function debería recibir varias soluciones, Gracias Team, nunca parar de aprender 😃
*
*

• No pongo el código visible para que lo intenten solucionar

export function delay(time, message) {
  return Promise(function (resolve, reject) {
    window.setTimeout(() => {
      resolve(message)
    }, time)
  })
}

Odio estos ejercicios, no sé si aún no hago suficientes ejercicios o no comprendo las instrucciones : (

Aúnque en VS Code sale bien aqui confunde, pero solo es poner la function sin implementar

.
.
.
.
.
.
.
.

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise(function (resolve, reject) {
    if (message != null || time < 0) {
      window.setTimeout(() => {
        resolve(message);
      }, time);
    } else {
      reject("no variables");
    }
  });
}

Mi solución.

💚
.
.
.
.
.

.
.
.
.
.

export function delay(time, message) {
  return new Promise((resolve, reject) => {
    if (Promise) {
      window.setTimeout(() => {
        resolve(message);
      }, time)
    } else {
      reject('No se puede completar')
    }
  })
}

Mi solución:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (time, message) {
      window.setTimeout(() => {
        resolve(message);
      }, time);
    } else {
      reject('The parameters are not met')
    }
  });
}

Mi solución en 3 lineas de código:
.
.
.
.
.

function delay(time, message) {
  return new Promise((resolve, reject) => {
    window.setTimeout(()=>resolve(message),time)
  })
}

• La función delay debe retornar una promesa, sintaxis:

return new Promise( (resolve, reject) => {

  código de la arrow function

  } ) 

• Debes usar la función setTimeout con el namespace window, sintaxis:

window.setTimeout( ( )  => {

  código de la arrow function

  }, milisegundos) 

reto

Soy el unico al que los playgrounds no le funcionan?
Le doy a correr pruebbas y no me muestra nada, se buguea, y eso me pasa en todos los cursos…

Mi codigo:

export function delay(time, message) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve(message)
    }, time);
  });
};
delay()
  .then((result) => { console.log(result) });

Dejo acá mi solución.
**
*
*
*
*
*
*
*
*
*
*

return new Promise((resolve, rejected) => {
    if (time >= 0) {
      window.setTimeout(() => {
        resolve(message);
      }, time);
    } else {
      rejected('Error, time is not defined');
    }
  });

la forma en que lo hice:

export function delay(time, message) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => resolve(message), time);    
  });
}

Mi codigo, estaba muy dificil

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise(function(resolve, reject) {
    window.setTimeout(() => {
      if (false) {
        reject(new Error('Algo salio mal'));
      } else {
        resolve(message);
      }
    }, time);
  });
}

Hola compañeros aqui les dejo mi solucion, implemente algunas validaciones y mensajes por si no se coloca el mensaje. Aunque para el playground mi respuesta es distinta.

delay(2000, 3)

function delay (time, message) {
    const showMessage = new Promise((resolve, reject) => {
        setTimeout(() => {
            if(typeof(message) == String) resolve(message);
            else reject('Debe poner un mensaje');
        }, time)
    });

    showMessage
        .then((message) => console.log(message))
        .catch((err) => console.log(err))
        .finally(() => console.log('Finally'));
}

Dejo mi solucion mas abajo:
*
*
*
*
*
*
*
*
*
*
*
*

export function delay(time, message) {
  return new Promise((resolve) => {
    window.setTimeout(() => resolve(message), time);
  });
}

Lo logré despues de revisar mis notas y pensar, sin ver los comentarios 😁✌️

function delay(time, message) {
  return  new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve(message)
    }, time)
  })
}

Creo que estaria bien un video del profesor explicando como es que deberiamos hacer el playground porque la verdad las guias a veces son bastante confusas de entender.

Solución

export function delay(time, message) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve(message)
    },time)
  })
}

Dejo mi código de la ejecución.

**
*
*
*
*
*
*

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise(function (resolve, reject) {
    window.setTimeout(() => {
      if (time > 0 && message != "") {
        resolve(message);
      } else {
        reject('Error en la ejecución');
      }
    }, time
    );

  });
}

Esta es mi versión

function delay(time, message) {
  const promise = new Promise((resolver, reject) => {
    if (time > 0) {
      window.setTimeout(() => {
        resolver(message);
      }, time);
    } else {
      reject(console.log("error"));
    }
  });
  return promise;
}

Dejo mi código aquí 👇, antes de verlo intenta hacerlo tú, no importa si fallas varias veces, lo importante es el proceso de aprendizaje y la oportunidad de mejorar:
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise(function (resolve, reject) {
    window.setTimeout(function () {
      if (message !== "") resolve(message)
      else reject("No hay mensaje")
    }, time)
  })
}

Mi solución!!
*
*
*
*
*
*
*
*
*
*
*

export function delay(time, message) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve(message);
    }, time);

  });
  
}

Solución
*
*
*
*
*
*
*
*

export function delay(time, message) {

    return new Promise( resolve => window.setTimeout( resolve, time, message ) );
  
};

🔥 Algo anda mal…

Al pasarle este código que está perfecto y cumple con el objetivo me dice que está mal y que debo corregirlo. Uno se queda algo loco porque en vsc funciona perfecto.

function delay(time, message) {
	return new Promise((resolve) => {
		setTimeout(() => {
			resolve(`Message: ${message}`);👈😐
		}, time);
	});
};

Después de un rato y de hacer varias pruebas le doy este código sin los Template literals o Template strings y funciona.

export function delay(time, message) {
  return new Promise((resolve) => {
    window.setTimeout(() => {
      resolve(message);🙂👍
    }, time);
  });
}

delay(2000, 'Hola')
  .then((result) => console.log(result));

No sé los demás, pero a mí se me hace un poquito mala onda que solo acepte determinado código, sabiendo que existen muchas formas de resolver los ejercicios. Hace dudar de lo que uno escribió esté bien. 😥

Spoiler
.
.
.
.
.
.
.
.

.
.
.
.

export function delay(time, message) {

  return new Promise((resolve, reject) => {
    if (time != null)
    {
      window.setTimeout(() =>{
        resolve(message)
      }, time)
    } else {
      reject("Elemento no encontrado")
    }
  })

  .then((result) => {
    return result
  }).catch((error) => {
    console.log(error)
  })
 
}

export function delay(time, message) {
return new Promise((resolve, reject) => {
window.setTimeout(() => {
resolve(message);
}, time);
});
}

delay(5000, “Terminó el tiempo de espera”).then((message) => {
console.log(message);
})

😄

  return new Promise(function (resolve) {
    window.setTimeout(() => { resolve(message) }, time)
  }) 

export function delay(time, message) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve(message);
    }, time);

  });
}

delay(2000, "Hello after 2s")
  .then((message) => console.log(message))

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise(function (resolve, reject) {
    window.setTimeout(() => { resolve(message) }, time)    
    
  })
}

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve(message);
      reject("Error");
    },time );
  });


}

Comparto mi solución desde VSCode utilizando then y catch:
*
*
*
*
*
*
*
*
*
*
*
*
![](

export function delay(time, message) {
  return new Promise(function (resolve, reject) {
    if (true) {
      window.setTimeout(() => {
        resolve(message)
      }, time);
    }
    else {
      reject("error");
    }
  });
}

Aquí les dejo mi solución haciendo uso también de ‘reject’
**
*
*
*
*
*
*
*
*
*

export function delay(time, message) {
  const promise = new Promise((resolve, reject) => {
    if (time && message) {
      window.setTimeout(function () {
        resolve(message);
      }, time);
    } else {
      reject('Error');
    }
  });
  return promise;
}

Este es mi código:
*
*
*
*
*
*
*
*
*
*
*

export function delay(time, message) {
  const miPromesa = new Promise((resolve, reject) => {
 
    window.setTimeout(() => {
      const exito = true;

      if (exito) {
        resolve(message);
      } else {
        reject("Ocurrió un error en la operación");
      }
    }, time);
  });

  miPromesa
    .then(resultado => {
      console.log(resultado);
    })
    .catch(error => {
      console.error(error);
    });
}

Aquí dejó mi código.

export function delay(time, message) {
  return new Promise(function (resolve, reject) {
    window.setTimeout(() => {
      resolve(message);
    }, time);
  })
}

Por alguna extraña razon, me dio error en la segunda prueba cuando lo ejecute, pero lo ejecute de nuevo y funciono.

/
/
/
//
/
/
/
/
/
/

export function delay(time, message) {
  // Tu código aquí 👈
  const promise = new Promise((res, rej) => {
    window.setTimeout(() => {
      res(message)
    }, time)
  })

  return promise;
}

Buenas,

Comparto mi solucion al ejercicio, lo hicen en Visual studio,

function delay(time, message) {
    return new Promise((resolve, reject) => {
      if (true) {
            resolve(setTimeout(()=>{
            console.log(message);
            },2000))
        }
    })
}

 delay (6000, "Hola");

A veces me cuesta bastante entender cuando proponen ejercicios para resolver, me gustaría que me pudieran colaborar con guias o tips para comprender mejor estos problemas, aclaro que ya hice cursos de lógica

Dejo mi código:

export function delay(time, message) {
  const promise = new Promise((resolve) => {
    window.setTimeout(() => {
      resolve(message);
    }, time);
  })
  return promise;
}
delay(2000, "Hello after 2s")
  .then((message) => console.log(message));
  
delay(3000, "Hello after 3s")
  .then((message) => console.log(message))

vaya estaba devolviendo una variable con la promesa, ese era mi error

Comparto mi código, muy buen ejemplo : )

**
*
*
*
*
*
*
*
*
*
*

export function delay(time, message) {
  return new Promise((resolve, reject) => {
    if (time < 0) reject("Error");
    window.setTimeout(() => {
      resolve(message);
    }, time);
  });
};

delay(2, "Hellow").then((message) => console.log(message));

Comparto mi código:
.
.
.
.
.
.
.
.
.
.

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve(message)
    }, time);
  });

}

Esta es mi solución para este reto 💚

\
Acá pueden probar el código:

// Solución al ejercicio de "Playgrounds"
export function delay(time, message) {
  return new Promise(function (resolve, reject) {
    window.setTimeout(function(){
      resolve(message);
    }, time);
 });
}

Mi solución:

export function delay(time, message) {
  return new Promise(function (resolve) {
    window.setTimeout(() => {
      resolve(message)
    }, time)
  })
}

Mi solución:

export function delay(time, message) {
  return new Promise((resolve, reject) => {
    if (time >= 0) {
      window.setTimeout(() => {
        resolve(message)
      }, time)
    } else {
      reject("Time must be positive")
    }
  })
}

SI al igual que yo no entesdiste a la primera, te dejo mi solucion explicada, ademas de un codigo que puedes correr en VSC para que realices pruebas

export function delay(time, message) {
  return new Promise((resuelve, rechaza) => {
    if (time > 0) {
      window.setTimeout(() => {
        resuelve(message)}, time)
    } else {
      rechaza('rechazado, el tiempo no puede ser    negativo')
    }
  })
}

Codigo de VSC

        const delay = function delay(time, message) {
            return new Promise((resuelve, rechaza) => {
              if (time > 0) {
                setTimeout(() => {
                  resuelve(message)}, time)
              } else {
                rechaza('rechazado, el tiempo no puede ser    negativo')
              }
            })
          }

          delay(2000, 'hola')
          .then((resuelve)=> console.log(resuelve))
          .catch((rechaza)=> console.log(rechaza));

export function delay(time, message) {
  // Tu código aquí 👈

  const promise = new Promise((resolve, reject) => {

    window.setTimeout(() => {
      resolve(message)
    }, time)

  })

  return promise
}

Todavía no me termina de convencer esto, parece que lo hizo alguien más y no Oscar

💚💚 Me tardé 3 días y volví a ver las clases de callbacks y promises, pero valió la pena para que esas escasas 7 líneas de código funcionen. 💚💚

.
.
.
.
.
.
.

export function delay(time, message) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve(message)
    }, time)
  })
}

Los aportes que realiza la comunidad son demasiado útiles para ir practicando y comprendiendo diferentes lógicas, muchas gracias por sus aportes!
*
*
*
*
*
*

export function delay(time, message) {
  const call = new Promise((resolve, reject) => {
    if (time >= 0) { 
      window.setTimeout(() => {
        resolve(message)
      }, time); 
    } else {
      reject ("Not")
    }
  })
  return call
}

Yo lo hice de esta manera, no se si este correcto, pues cuando le doy a correr pruebas se queda colgado y no me da un resultado positivo o negativo. Alguien podria indicarme si lo hice correctamente o no? Gracias de antemano!

export function delay(time, message) {
const promise = new Promise(function (resolve, reject) {
resolve()
});
const time = 100;
const message = “logrado”

setTimeout(() => {
const i = new Promise(function (resolve, reject) {
if (time > 900) {
resolve(Hello, ${time} is good, so ${message});
} else {
reject(‘Not timer’);
}
});

i.then((result) => {
  console.log(result);
}).catch((error) => {
  console.log(error);
}).finally(() => {
  console.log('Is done');
})

}, 1000);
}

Comparto mi aporte, pero no entendí como debo validar que la ejecución se realice en el tiempo definido.

    export function delay(time, message) {
  return new Promise(function (resolve, reject) { 
    window.setTimeout(() => { 
      resolve(message);
    },time)
  });
}

Lo hice una sola línea de código.
Algo extraño es es que la primera vez que lo puse a prueba me lanzó error y pensé que me había equivocado, pero al revisarlo me di cuenta que todo estaba bien. Como acto seguido volví a correr pruebas y pasó normal 🤔. Creo que hay que revisar el sistema de pruebas, debe tener algún error.

Primero intenta resolverlo antes de verlo:
*
*
*
*
*
*
*
*
*
*
*
*
*

export const delay = (time, message) => new Promise((resolve, reject) => window.setTimeout(() => resolve(message), time))

Mi humilde solucion

export function delay(time, message) {
  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve(message);
    }, time)
  })
}

Aca les comparto mi solucion:

function delay(time, message) {
  
   const promesa= new Promise((resolve,reject)=>{
      setTimeout(()=>{
      if(typeof message ==='string') {
        resolve(message)
      } else {
        reject("ney ney")
        
      }
    },time)
  }) 
 return promesa.then((resul)=>{console.log(resul);})
   .catch((error)=>{console.log(error);})
   .finally(()=>console.log("Finally"))
}
 
delay(2000,"Hey mani")

Excelentes ejercicios. Al principio me costó entender como resolver y como aplicar lo aprendido.
La práctica y repasar las clases son fundamentales.

Platzinautes: no se desesperen si no entienden del todo, la programación es muy abstracta, hay que valorar que si no se comprender del todo, al menos se comprende mas que antes, e ir asi de a granito de arena.

export function delay(time, message) {
  // Tu código aquí 👈
  const promise = new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve(message)
    },time)
  })
  return promise
}
delay(2000, "Parce, me demoro dos segunditos").
  then((message) => console.log(message))

Mi solución:

export function delay(time, message) {
  const promise = new Promise((resolve, reject) => {
    window.setTimeout(()=> resolve(message), time)
  })
  return promise;
}

Para la gente que le cueste, os pongo el ejercicio que estaba haciendo cuando lo tenia mal, y luego cuando lo he corregido para que os ayude en la contrucción de vuestra logica:
*
*
*
*
*
*
MAL HECHO:

const { rejects } = require("assert")
const { resolve } = require("path")

//export 
function delay(time, message) {
    setTimeout(() => {
        new Promise((resolve,rejects) => {
            if (resolve) {
                return message
            }
        })

    },time)
}

delay(2000, "Mensaje despues de 2 segundos").then(() => console.log(object))

CORREGIDO y RESUELTO

export function delay(time, message) {
  return new Promise((resolve, rejects) => {
    window.setTimeout(() => {
      resolve(message); // Se devuelve con la funcion resolve
    }, time)
  })
}

delay(2000, "Mensaje despues de 2 segundos").then((returnedMsg) => console.log(returnedMsg))//Podemos usar la palabra que queramos (no pongo message para no liarme) 

Mi solucion:

export function delay(time, message) {
  return new Promise((resolve) => window.setTimeout(() => resolve(message), time))
}

Explicacion propia (quizas puedo equivocarme en algunas cosas):

• Se retornar una new Promise con corresponde Resolver (resolve) dentro de la funcion delay
• reject - en este caso en particular- es omitible (asumiendo que las pruebas son introducidas correctamentes). Por otro lado, se puede usar reject para validar que el numero sea de un entero positivo
• La funcion .setTimeout() se puede envolver dentro la Promise

//* Ejercicio
const delay = (time, message) => {
return new Promise((resolve) => {
setTimeout(() => {
resolve(message + " " + (time / 1000) + " segundos");
}, time);
})
}

delay(2000, “se hizo en tantos segundos”).then((result) => {
console.log(result);
});

Se tarda mucho en realizar las pruebas o de plano se bloquea, deberían quitarlo y utilizar pruebas como el de midudev que no necesitan usar windows para funcionar

Les dejo mi solución

Intenté validar primero que se envie un mensaje por argumento, también tiene una validación que el tiempo debe ser minimo 0 segundos

export function delay(time, message) {
  // Tu código aquí 👈
  if (message) {
    return new Promise((resolve, reject) => {
      if (time >= 0) {
        window.setTimeout(() => {
          resolve (message)
        }, time)      
      } else {
        reject ('la cantidad de tiempo debe ser mayor a 0')
      }
    })    
  } else {
    return
  }
}```

Comparto mi solucion validando el error antes de devolver resolve

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    if (!time || !message) reject('Faltan datos');
    window.setTimeout(() => {
      resolve(message);
    }, time);
    
  })
}

delay(3000, "Hello after 3s")
  .then((message) => console.log(message));

version modernizada

export const delay = (time, message) => {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    message && time
      ? window.setTimeout(() => {
        resolve(message)
      }, time)
      : reject('promise rejected');
  });
};

Here you can see how I made it!

export function delay(time, message) {
  return new Promise((resolve) => {
    window.setTimeout(() => {
     resolve(message)
   }, time)
 })
}

Se me complico un poco a la hora de comprender el texto, ya que pensaba que la promesa se iba a crear luego del tiempo puesto, pero no, aquí dejo mi ejercicio resuelto
*
*
*
*
*
*
*
*
*
*
*
(Si no lo has hecho hazlo)

export function delay(time, message) {
  return new Promise(function (resolve, reject) {
    window.setTimeout(() => {
      resolve(message);
    }, time)
  }); 
}

export function delay(time, message) {
  return new Promise((resolve) => {
    window.setTimeout(() => {
      resolve(message);
    }, time);
  });
}

Otra forma utilizando solo un prarametro para la promesa.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

export function delay(time, message) {
  // Tu código aquí 👈
  let prom = new Promise(
    (res) => {
      window.setTimeout(() => {
        res(message);
      }, time);
    }
  );
  return prom;
}

}

export function delay(time, message) {
  return new Promise((resolve) => {
    window.setTimeout(() => {
      resolve(message);
    }, time);
  });
}```

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    window.setTimeout(() => { resolve(message)},time)
  })
}

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    window.setTimeout(() => { resolve(message)},time)
  })
}

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    window.setTimeout(() => { resolve(message)},time)
  })
}

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    window.setTimeout(() => { resolve(message)},time)
  })
}

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    window.setTimeout(() => { resolve(message)},time)
  })
}

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    window.setTimeout(() => { resolve(message)},time)
  })
}

Las soluciones que hago en VSC no pasan las pruebas en el playground, y las que sí pasan en el playground no lo hacen en el VSC. Me tiene muy confundido.
 
De igual forma aquí dejo mi solucion al reto 😄!
 

Bien estos ejercicios ayudan a practicar aqui dejo una explicacion y una solucion, antes de ver la respuesta trata de leer un poco el problema y entender… Siente libre para revisar el codigo e implementar alguna otra solucion.
*
*
*
*
*

La función delay es una función que recibe dos parámetros: time y message. La función usa la función setTimeout para esperar el tiempo especificado en milisegundos (es decir, time) y luego devuelve una promesa que se resuelve con el mensaje especificado (message).

La promesa se puede usar de forma asíncrona mediante el uso del método then. Por ejemplo, en el ejemplo 1 se llama a delay con un tiempo de espera de 2000 milisegundos y un mensaje de “Hello after 2s”. Después de 2 segundos, la promesa se resuelve y el mensaje se imprime en la consola.

La función delay es útil para esperar un tiempo específico antes de realizar alguna acción o para simular un proceso asíncrono. Por ejemplo, podrías usar delay para esperar un tiempo antes de realizar una llamada a una API o para simular la carga de un proceso en tu aplicación.

function delay(time, message) {
  return new Promise((resolve) => {
    window.setTimeout(() => {
      resolve(message);
    }, time);
  });
}

Yo lo hice de la siguiente forma
*
*
*
*
*
*
*
*
*
*

export function delay(time, message) {
  // Tu código aquí 👈
  return new Promise((resolve, reject) => {
    try {
      window.setTimeout(() => {
        resolve(message);
      }, time)
    } catch (e) { 
      reject(e);
    }
  })
}

Esta fue la forma en que lo hice

export function delay(time, message) {

  return new Promise((resolve, reject) => {
    window.setTimeout(() => {
      resolve(message);
    }, time);
  });

}

Dejo mi solución al reto:
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*

export function delay(time, message) {
  return new Promise(function (resolve, reject) {
    window.setTimeout(() => {
      resolve(message);
    }, time);
  });
};

un poco simplificado xD

export function delay(time, message) {
  return new Promise(resolve => window.setTimeout(() => resolve(message), time))
}

delay(2000, "Hello after 2s").then(message => console.log(message))