Playground: Ejecuta un callback con 2s de demora

esta excelente !
los veo mejores que los quizes

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

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

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

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

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
 

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

siento que le falta algún tipo de feedback al botón de correr pruebas, por momento s le doy click y por la sensación de que no hace nada le doy de vuelta y pierdo mas de un intento sin querer

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

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

Genial el playgraound! genera mucho más valor a la realización de los cursos!
Un apunte, se podría mejorar las notas con referencia a la explicación así como trabajar para evitar usas window

Esta implementación de playground es genial!!! me encanta 😍. Ojalá se implente en todos los cursos practicos

Que gozu la nueva implementación, mucho mejor para practicar que los quizes

creo que debeoria ser un poco mas clara la nota

Me encantó este playground y aunque me tomó un poco entender qué era lo que se debía hacer, no sé si será mi propia falta de práctica o que el enunciado no está bien fácil de entender de buenas a primeras; de todas formas, disfruté el reto.

Esta bastante bien esta nueva funcion de los playgrounds, le agrega otro dinamismo y es mejor al simple preguntas y respuestas.

Es la primera vez que pruebo esta nueva función de Platzi que son los playgrounds, la verdad me decepciona un poco porque en esta ocasión yo lo hice de la forma correcta, pero el sistema me lo rechaza porque parece que tengo que hacerlo de una forma específica :T
.
Spoiler de la solución
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Esta es la forma en la que yo lo hice en primer lugar con la ayuda de la consola de Firefox para hacer pruebas:

export function runCode(callback) {
  function showAnimal(callback) {
    console.log(`This animal is a ${callback}`);
  };
  window.setTimeout(showAnimal, 2000, 'Fox');
}

Y esta es la forma en la que al final lo hice para que me aceptara el reto…

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

Creo que falta pulir este sistema en el sentido de explicar mejor como funciona y también que sea un poco mas “inteligente”

Ya vi la respuesta y ya comprendí que quieran que hiciera, entonces mi respuesta no es tan diferente a la que muestra la interfaz:

Si no comprendes que quieren. Quieren que usea el callback (runCode(callback), solo el callback) y que se ejecute 2 segundos después

Es bastante fácil, prácticamente te dieron la respuesta al decir que uses: window.setTimeout();

.
.
.
.
.
.
.
.
.
.

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

Porque no le entendí?

Esta pieza de código me desconcertó

export function runCode(callback) {


}

No supe leer o no fueron muy claros ¿?

Me gustaría que dijera:

Haz que este callback se ejecute con un retraso de 2 segundos. (Refiriendose al callback que importaron )
Yo creí que yo tenía que crear un callback y luego usar un window.setTimeout

Este fue mi intento al no comprender.

  function mensaje(callback) {
    var text = "llegue 2seg tarde nada más";
    callback(text);
  }

  function tiempo(carta) {
    window.setTimeout(carta, 2000);
  }

  mensaje(tiempo);

Wow, cada vez mejorando nuestra forma de aprender con estos detalles, gracias Platzi y a todo su equipo, que genial. 😀

Esta excelente el playgrownd, me parece que es una evolución a los quiz muy acertada, muchas felicitaciones 👏👏.

Mil veces mejor esto que los quizzes 🚀

Esto es de lo poco que le faltaba a Platzi, ¡¡brutal!!

super cool este ejercicio.

Creo que en Visual Studio Code seria algo asi:

function showMessage(message) {
   return message = console.log('Log after 2s');
}
function runCode(callback) {
   setTimeout(() => {
      callback();
   }, 2000);
}
runCode(showMessage);

Y este me funciono en el reto:

export function runCode(callback) {
  window.setTimeout(callback, 2000);
}
function print(message) {
  return message;
}
runCode(print('Log after 2s'));

entre despues de un tiempo al curso de asincronismo y se me a estado olvidando pero aqui les dejo mi codigo:

export function runCode(callback) {
window.setTimeout(callback, 2000);
}
function print(mensaje) {
console.log("execute function 2s after " + mensaje);
}
runCode(print(“by john”));

Mejor que los quizes, dado que nos lleva mas alla en el desarrollo de nuestras habilidades.

ya hacia falta este tipo de features en Platzi, eso si tarda mucho en ejecutar pero espero que poco a poco lo vayan mejorando.

BROOOOOOOOOOO, QUE BUEN FEATURE

Me encanta esta forma de evaluacion!

Iba en la clase 14 cuando veo que agregaron una nueva actividad, jajaja. Me parece genial.

Genial! Que gran implementacion