Playground: Ejecuta un callback con 2s de demora

Voy a dejar el código abajo, pero si no has logrado el reto todavía, intenta terminarlo primero.\

**
*
*
*
*
*
*
*

export function runCode(callback) {
  window.setTimeout(callback, 2000)
}

esta excelente !
los veo mejores que los quizes

Es la primera vez que veo un playground en Platzi. Es chévere, aunque no me parece tan clara la nota que pusieron. Igual, se agradece mucho este espacio

Aplaudo mucho la integración de estas herramientas, pienso que le falta pulir un poco a la explicación. Gracias por hacer los cursos más dinámicos!

Justo estaba terminando el módulo ahorita y acaban de implementar estas pruebas ✨💚 me encanta 😀

Excelente iniciativa súbanle el sueldo al de la idea.

Hay que intentar se un poco mas claro en la pregunta, yo entendí que teníamos que crear un callback con un setTimeOut, no que teníamos que terminar el que mencionan en el ejemplo. Eventualmente ya me di cuenta de lo que esperaban que hiciéramos.

muy poco intuitivo este playground

El playground está genial, pero se demora mucho para ejecutar el código.

También logre hacerlo de esta manera

function runCode(name, callback) {
    return setTimeout(function () {
      console.log(callback(name));
    }, 2000);
  }
  
  function name(name) {
    return `Hola ${name}`;
  }
  
  runCode('Jesus', name);

Tengo que felicitarlos, no sé si de aquí en adelante los cursos van a venir con más de estas pruebas, espero que si, ya que me parece genial que tengamos problemas para ir resolviendo, ya que creo que aprendemos más en el campo.

😎💪🏻👏🏻👏🏻👏🏻

Hola!

Esta es otra manera de hacer el ejercicio tambien. Intente hacerlo en el playground pero no lo aceptaba. Tuve que hacerlo de la forma tradicional (aunque me gusta mas el de la imagen). Suerte a todos!

Muy chévere el PlayGround, aun así, las instrucciones no son muy claras.

Asíncronismo en JS - Notion

Para mi que estoy empezando a ver el tema es un poco complicado de entender, estoy buscando otros videos que expliquen mejor y usando otras herramientas como chatgpt para que me ayuden en mi tarea de aprender, por lo pronto esta es la solución que me funciono según lo que he entendido.
export function execCallback(callback) {
// Tu código aquí 👈
window.setTimeout(() => {
const myFunc = () => console.log(‘Log after 2s’)
callback(myFunc);
}, 2000)
}

execCallback()

Sí, es genial la idea del Playground, más sin embargo, las instrucciones no son para nada claras , deberían de ser más específicos y no tan “técnicos” de lo que solicitan para solucionarlo…
De igual manera, no me parecían tan mal los quizzes, estaría bueno que lo combinaran para también reforzar un poco la teoría y práctica. 😃

la verdad no comprendí como hacerlo y después del primer intento me voto no me dejo hacerlo mas, así que preferí hacerlo en la terminal preciosa que tiene el Firefox
 

reto

export function execCallback(callback) {
  // Tu código aquí 👈
  return window.setTimeout(callback, 2000)
}

Yo lo hice así:

Solución:

export function execCallback(callback) {
  window.setTimeout(() => {
    return callback();
  },2000) 
}

Aplaudo este tipo de propuestas de platzi que nos permiten poner a prueba lo que estamos aprendiendo, de verdad son excelentemente útiles. Al igual que otros compañeros también comparto la idea de que quizás se debe mejorar la forma en la que se expresa la idea de lo que debemos hacer(por lo menos en este ejercicio), porque se hizo un poco confuso entenderlo desde el inicio, pero fuera de eso de verdad esto está genial.

MI SOLUCIÓN
*
*
*
*
*

Re bugueado el playground

Solución:

Según la guía, ya tenemos una función definida previamente y esta se ve así:

// Se crea la función 
const myFunc = () => console.log('Log after 2s');
// Se la pasamos como argumento a la función con el callback
execCallback(myFunc);

Solución:

export function execCallback(callback) {
  window.setTimeout(callback, 2000);
}

Si copiamos esto en la consola del navegador recuerda seguir este orden, de lo contrario tendremos un error:

const myFunc = () => console.log('Log after 2s');

function execCallback(callback) {
  window.setTimeout(callback, 2000);
}

execCallback(myFunc);

// Output:
// Log after 2s

Mi solucion.
Primero me confundi un poco ya que por alguna razon no entendia bien la guia

export function execCallback(callback) {
  // Tu código aquí 👈
  window.setTimeout(callback,2000)
}

Lo logré, mi forma de hacerlo fue así:

export function execCallback(name, placa) {
// Tu código aquí 👈
console.log(Tu conductor asignado, ${name}, con placas ${placa} llegará en 3 minutos);
}

setTimeout(execCallback, 2000, ‘Alexander’, ‘MTN-06D’);

Este es mi código, realmente me costo mucho hacerlo, mas de lo que pensaba y no se si esta bien, si alguien me lo corrobora genial, muchas gracias! 😄

< export function execCallback(callback) {
  console.log('Como estas ' + nombre() + ' ?');
  callback();
};

function nombre() {
  let name = 'Bruno';
  return name;
};

window.setTimeout(() => {
  execCallback(nombre);
}, 2000); >

Solo hay que terminar la funcion que ya esta implementada.

export function execCallback(callback) {
  window.setTimeout(callback, 2000);
}
console.log('log after 2s');

export function execCallback(callback) {
  // Tu código aquí 👈
  window.setTimeout(callback, 2000)
}

export function execCallback(callback) {
  window.setTimeout(callback, 2000);
}

Esta es mi solución, pero no me lo corrió el playground.
Dejo espacios para no spoilear con mi respuesta
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

const myFunc = () => console.log('Log after 2s')
export function execCallback(callback) {
  window.setTimeout(callback, 2000)
}

execCallback(myFunc)

Aquí tienes una posible solución para la función execCallback utilizando setTimeout para demorar la ejecución del callback por 2 segundos:

export function execCallback(callback) {
  window.setTimeout(callback, 2000);
}

Dentro de la función execCallback, llamamos a setTimeout pasando el callback como primer argumento y 2000 (que representa 2 segundos en milisegundos) como segundo argumento. Esto hará que el callback se ejecute después de un retraso de 2 segundos.
.
Recuerda que en este ejemplo se está utilizando window.setTimeout para poder monitorear el uso de la función en la ejecución de pruebas, como se menciona en el enunciado.

Yo lo hice asi

export function execCallback(callback) {
  window.setTimeout(() => {
    callback(console.log('Log after 2s'))
  },2000)
}

Últimamente esta como malo el Playground este, se demora un siglo en hacer un test y a veces ni lo hace. Fue bonito mientras duro, ahora a saltarselo

Hola hay un problema con los playground, están tardando demasiado en responder, soy el único?

Mi codigo 😄, lean bien, necesitan llamar a window

export function execCallback(callback) {
  // Tu código aquí 👈
  return window.setTimeout( callback , 2000)
}

Buenas,

Comparto la solucion que le encontre al ejercicio!
La verdad estan muy buenos estos ejercicios con consola.

function time(){
    return setTimeout(()=>{console.log ("Log after 2s")},2000);
  };
  

function execCallback(callback) {
   return callback();
  };

 
execCallback(time);

ALTO AHÍ!!!

SI SE PODRÁ LA PRÓXIMA VEZ

function execCallback(callback) {
  window.setTimeout(callback, 2000);
}

Me gustan mucho estos retos para poner en práctica los conceptos inmediatamente. Aquí les dejo mi solución 💚

Acá pueden probar el código:

// Solución al ejercicio de "PlayGrounds"
export function execCallback(callback) {
    window.setTimeout(
      callback, 2000);                          
    }

Dejo aqui mi solucion
*
*
*
*
*
*
*
*
*

export function execCallback(callback) {
  window.setTimeout(callback, 2000)
}

`

export function execCallback(callback) {
  window.setTimeout(callback, 2000);
}

function greetings() {
  console.log('Hola platzi');
}

execCallback(greetings);

Si le das 1000 veces al correr pruebas puedes llenar la pantalla de confetis .
0_0 0_0 0_0 0_0 0_0

Mi humilde código aunque no es válido para playground funciona en la consola

function execCallback(callback) {
    console.log(callback)
}

setTimeout(() => {
    execCallback("Execute myFunc 2s after")
}, 2000)

Mi solución:

export function execCallback(callback) {
  return window.setTimeout(callback, 2000)
}

export function execCallback(callback) {
  // Tu código aquí
  window.setTimeout(() => {
    callback();
  }, 2000)
}

function test() {
  console.log('Hola :D')
}

execCallback(test)

Me sumo a los comentarios que hay que mejorar la explicación de lo que piden, para llegar a comprender claramente lo que se requiere.

7/26 Playground: Ejecuta un callback con 2s de demora
🐸
🐸
🐸
🐸
🐸
🐸
🐸
🐸
🐸
🐸
🐸

export function execCallback(callback) {
  // Tu código aquí 👈
  window.setTimeout(callback, 2000)
};

Escudo anti spoilers ⬇️⬇️⬇️ scroll Dow answer.
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️

export function execCallback(callback) {
  window.setTimeout(
   callback, 2000)
}
// funciones pruebas
function myFunc() {
  console.log("log after 2 seg")
}
function grettin() {
   console.log("Hello,Word")
 }
// se puede ejecutar con cualquier funcion que le pases
// primera ejecucion
execCallback(myFunc)
//segubda ejecucion y asi sucesiamente puedes usar cualquier funcion  que le pases para quese ejecute 2 seg despues.
execCallback(grettin)

Se debe ejecuar un setTimeout con la funcion callback que es la que nos estan dando como parametro, se define el tiempo en 2000ms
.

export function execCallback(callback) {
  window.setTimeout(callback, 2000);
}

Acá dejo mi solución:

<export function execCallback(callback) {
  // Tu código aquí 👈
  window.setTimeout(() => {
    // code
  }, 2000)
  callback(myFunc);
}

const myFunc = () => console.log('Log after 2s')
execCallback(myFunc);> 

Le di tantas vueltas para que terminara siendo sencillo jajaja.

export function execCallback(callback) {
  return window.setTimeout(callback, 2000);
}

export function execCallback(callback) {
  // Tu código aquí 👈
  
  return  window.setTimeout(callback, 2000)
  
}

Este playground estuvo bien chevere

export function execCallback(callback) {
  window.setTimeout(callback, 2000);
}

Jeje Lo logré, aunque si estaba un poco rara la explicación.

export function execCallback(callback) {
  // Tu código aquí 👈
  window.setTimeout((callback), 2000);
}
const saludar = () => console.log('Hola Mundo');
execCallback(saludar);

Haber yo lo resolvi de esta manera supongo que habra mejores maneras de hacerlo pero aqui mi aporte…

Lo oculto un poco para que no se expoileen jeje
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function execCallback(callback) {
  // Tu código aquí 👈
  return window.setTimeout(callback, 2000);
}

function hola() {
  console.log('Hola');
}

execCallback(hola);

El playground no funciona, pero lo hice en VSC.

export function execCallback(callback) {
//la funcion arrow de ejemplo te hace pisar la rama, pero esta bien asi:
window.setTimeout(callback, 2000);
//los 2000 representa milisegundos 2000= 2 seg
}

//(El botón verde del margen derecho de abajo no funciona)

Está muy bueno y ya tuve la oportunidad de hacer los retos de los playground anteriores de otros cursos.

🚩⚠️ Solo me parece que la explicación de lo que teníamos que hacer en este fue muy confuso. De mi parte tuve que ver los aportes de la comunidad. Y en este modulo hay pocos.

La solución era sencilla, pero me lo compliqué bobamente, así que… que mejor que un callback? Un callback dentro de otro callback

export function execCallback(callback) {
  function hi(p1) {
    return p1
  }

  window.setTimeout(
    function () {
      console.log(callback(hi("hi")))
    }
    , 2000)
}

Un poco confuso en las instrucciones, pero se logró 😄

export function execCallback(callback) {
  window.setTimeout(callback, 2000);
}

Me la estaba complicando al principio con la función arrow del ejemplo, pero terminó siendo muy fácil

window.setTimeout(callback, 2000);

export function execCallback(callback) {
  window.setTimeout(() => {
    callback();
  }, 2000);
}

No me funciona :’(

Acá dejo mi humilde aporte grupo, saludos!

function execCallback(callback) {
  window.setTimeout (callback, 2000)
}

const myFunc = () => {
  console.log('Log after 2s');
}

execCallback(myFunc);

💚

El ejercicio no se entiende del todo y es muy lento para mostra el resultado. Sin embargo, la idea es buena.

export function execCallback(callback) {
  window.setTimeout(() => {
    callback();
  }, 2000);
}

Opino lo que la Mayoria…El ejercicio no esta bien planteado !!

La guía del ejercicio no es del todo clara a simple vista, pero lo que es importante tener en cuenta es que el callback que envían en las pruebas es la función completa, no solo el nombre de una función.

No es clara la nota que se muestra, lo intente hacer tal cual como oscar barajas lo hizo en el video anterior… pero no funciono … mi pregunta es la respuesta era única?

Me agrada la idea del playground, ayuda a practicar los conceptos… Lo he visto en algun lado estoy seguro, pero bien por Platzi.

Aqui les dejo otra implementacion, antes de ver la solucion intenta resolverlo:
*
*
*
*
*
*
*
*
*
*

<// Tu código aquí 👈
  window.setTimeout(() => {
    callback();
  },2000)> 

esto es muy interactivo, muchas gracias por siempre pensar en el dinamismo de las pruebas.

Ya de varios playgrounds que he hecho, veo que la redacción de la guía tiende a confundir lo que pide el ejercicio. A veces menos es más pero si está bien escrito.
Por algo es que la documentación no la escriben programadores.

me encantan estos ejercicios, pero en este caso la pregunta no es clara en su planteamiento, creo que seria bueno si revisaran un poco la manera de plantear los ejercicios