es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Número de veces que se necesita llamar al callback antes de que se ejecute.

26 Jul, 2023 Programación

Obtuve 4 preguntas de entrevista y una de ellas es esta:

Escribir una función after que tome el número de veces que se debe llamar al callback antes de ser ejecutado como primer parámetro y el callback como segundo parámetro. 

function after(count, func) {
  // Implementar la función 'after'
}

var called = function () { console.log("hello") };
var afterCalled = after(3, called);

afterCalled(); // -> no se imprime nada
afterCalled(); // -> no se imprime nada
afterCalled(); // -> se imprime 'hello'

La forma en que resolví el problema es esta:

function after(count, cBack) {
  localStorage.setItem("aCount", count);
  return function () {
    let currCount = localStorage.getItem("aCount");

    if (currCount == 1) {
      cBack();
    } else {
      localStorage.setItem("aCount", --currCount);
    }
  };
}

let called = function () {
  console.log("hello");
};

let afterCalled = after(5, called);

afterCalled();
afterCalled();
afterCalled();
afterCalled();
afterCalled();

Quiero decir, el código funciona como se pretende, pero tengo la sensación de que localStorage no es la forma correcta. ¿Me estoy perdiendo algo? ¿Hay algo en las funciones de callback que pueda usar o “debería” usar para resolver este problema? Si es así, ¿qué debería buscar?

Tags:  ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Como experto en TI especializado en JavaScript y funciones de devolución de llamada, definitivamente existen otras formas de resolver este problema sin utilizar localStorage. Una opción es utilizar un closure para hacer un seguimiento del contador y devolver la función interna como resultado de la función after. Aquí tienes un ejemplo:

    function after(count, cBack) {
  let currCount = 0;
  return function () {
    if (++currCount >= count) {
      cBack();
    }
  };
}

let called = function () {
  console.log("hello");
};

let afterCalled = after(3, called);

afterCalled(); // -> no se imprime nada
afterCalled(); // -> no se imprime nada
afterCalled(); // -> se imprime 'hello'

    En esta solución, la función after crea un closure que incluye la variable currCount y la función interna devuelta. La función interna incrementa currCount cada vez que se llama, y ejecuta la función de devolución de llamada cuando el contador alcanza o supera el umbral especificado.

    Otra opción es utilizar la función setTimeout para retrasar la ejecución de la devolución de llamada hasta que se haya realizado un cierto número de llamadas. Aquí tienes un ejemplo:

    function after(count, cBack) {
  let currCount = 0;
  return function () {
    if (++currCount >= count) {
      setTimeout(cBack, 0);
    }
  };
}

let called = function () {
  console.log("hello");
};

let afterCalled = after(3, called);

afterCalled(); // -> no se imprime nada
afterCalled(); // -> no se imprime nada
afterCalled(); // -> se imprime 'hello'

    En esta solución, la función after utiliza la función setTimeout para ejecutar la devolución de llamada después de un retraso de 0 milisegundos. Esto asegura que la devolución de llamada se ejecute en una nueva tarea, permitiendo que todas las llamadas a afterCalled se completen antes de que se ejecute la devolución de llamada.

Comments are closed.