Question

我必须编写一个函数 myFunction ，该函数接受另一个函数（ myCallbackFunction ）作为参数。

myFunction将返回结果函数 myResultFunction（），该函数调用回调

myResultFunction每 100毫秒

被调用

回调函数； myCallbackFunction每 300毫秒

最多应调用一次

是这样的：

function myFunction(paramFunction){
  return setInterval( myResultFunction(paramFunction); , 100);
  // paramFunction is the callback taht should be called at once 300ms  
}

function myResultFunction(paramfunction){
      return setInterval( paramfunction(); , 300);
}
myFunction(myCallbackFunction);

我需要适应这种行为：

myFunction ，因此在最近300毫秒内尚未调用 myCallbackFunction
在t = 0ms时：myResultFunction();
在t = 100ms ：myResultFunction();
在t = 200ms ：myResultFunction();
在t = 300毫秒：myCallbackFunction() ;
此行为应循环，以使回调mybe第一次调用

建议以编写 myFunction ， myCallbackFunction 和 myResultFunction ?? **

Answer 1

这是您实际利用ES6中可用的iterators and generators的时候。基本上，myFunction是迭代器，它将在while(true)循环中无限期地进行迭代。对于每次迭代，将迭代增加1。每4个迭代将返回myCallbackFunction()的结果，否则将返回myResultFunction()的结果。

实例化迭代器后，可以按所需的时间间隔在其上调用.next()方法：在您的情况下，您希望它每100ms步进一次。我稍微调整了以下概念验证，使其每 1000ms 步进一次，以便您可以实际看到正在发生的情况：

function* myFunction(callback) {
    let count = 1;
    while (true) {
      let output;
      if (count % 4 === 0)
        output = callback();
      else
        output = myResultFunction();
      
      count++;
      yield output;
    }
}

function myResultFunction() {
  return 'myResultFunction(): called every count';
}

function myCallbackFunction() {
  return 'myCallbackFunction(): called at every fourth count';
}

var iteratorFunction = myFunction(myCallbackFunction);

// Run the first time without delay
console.log(iteratorFunction.next().value);

// Step to the next iteration every n seconds
window.setInterval(() => {
  console.log(iteratorFunction.next().value);
}, 1000);

更新：好像OP想要先调用callback()方法。在这种情况下，上面代码段中的let count = 1应该更改为let count = 0：

function* myFunction(callback) {
    let count = 0;
    while (true) {
      let output;
      if (count % 4 === 0)
        output = callback();
      else
        output = myResultFunction();
      
      count++;
      yield output;
    }
}

function myResultFunction() {
  return 'myResultFunction(): called every count';
}

function myCallbackFunction() {
  return 'myCallbackFunction(): called at every fourth count';
}

var iteratorFunction = myFunction(myCallbackFunction);

// Run the first time without delay
console.log(iteratorFunction.next().value);

// Step to the next iteration every n seconds
window.setInterval(() => {
  console.log(iteratorFunction.next().value);
}, 1000);

Answer 2

您可以按需要的顺序将函数存储在数组中，并在索引上使用闭包，并在每次调用后递增该索引。必要时进行调整。

httpd-vhosts.conf

Answer 3

var timer = 0;
var step = 100;
var callbackStep = 300;

function myFunction(callback){
  setInterval( function() {
    if(timer >= callbackStep && timer % callbackStep === 0) {
      callback()
    } else {
    // myResultFunction(); dont really need this, but can be called.
    }
    timer += step
  }, step);
}

myFunction(function(){console.log(`Once every ${callbackStep}ms. Current ${(timer ? timer : 100) / (step / 100 * callbackStep)}`);});

JS：如何编写一个函数，将另一个函数作为参数并返回一个函数

3 个答案: