如何在javascript数组中每5分钟调用一个函数

这是一个很好的用例 setInterval ,我们只定义它运行的时间间隔(5分钟),并将其添加到事件循环中。知道了这一点,我们可以采取一点不同的方法,使用计数器来跟踪传递的间隔数,这允许我们处理每个bucket。

const everyTen = ['a', 'b', 'c'];

const updateDataPost = (data) => {
  console.log(`updateDataPost ${data}`);
};

const updateDataBasic = (data) => {
  console.log(`updateDataBasic ${data}`);
};

let intervalsPassed = 0;

const interval = setInterval(() => {
  const currentBucket = everyTen[intervalsPassed++];
  updateDataPost(currentBucket);
  updateDataBasic(currentBucket);
  if (intervalsPassed >= everyTen.length) {
    console.log('no more buckets, stopping interval')
    clearInterval(interval);
  }
}, 1000 * 60 * 5);

输出:

"updateDataPost a"
"updateDataBasic a"

"updateDataPost b"
"updateDataBasic b"

"updateDataPost c"
"updateDataBasic c"

这是一个JS bin,我设置为5秒,使它更快地测试 https://jsbin.com/fafewelufi/edit?js,console

setInterval(function(){
     UpdateDataPost(element); //Function A
     UpdateDataBasic(element); //Function B
   }, 1000*60*5);

如果每次都要更新不同的元素,我会在函数中包含某种计数器。举个例子:

var i = 0;
setInterval(function(){
     UpdateDataPost(EveryTen[i]); //Function A
     UpdateDataBasic(EveryTen[i]); //Function B
     i++;
   }, 1000*60*5);

如果您想在每个项目使用后停止,那么这可能是最好的方法:

var i = 0;

var interval = setInterval(function(){
     if(i <EveryTen.length) {
       UpdateDataPost(EveryTen[i]); //Function A
       UpdateDataBasic(EveryTen[i]); //Function B
       i++;
     } else {
        clearInterval(interval);
     }
   }, 1000*60*5);

我觉得这是一个递归的问题:)

你为什么不打电话 setDelay 在内部 setInterval ? 以您的例子:

 EveryTen.forEach(element => {
   setDelay(element)
 });


 const setDelay = (element) => {
    setTimeout(function(){
       UpdateDataPost(element); //Function A
       UpdateDataBasic(element); //Function B
       setDelay(element);   // Added this.
    }, 60 * 5 * 1000);
 }

设置间隔 :

const startInterval = (element) => {
   setInterval(function(){ 
       // Do something
   }, 60 * 5 * 1000);
}

一 所有值的函数

var arr = ["a", "b", "c"];

function output(val) {
  console.log(val);
}

function setTimeouts(arr, ms, f) {
  arr.forEach(function(val, i) {
    setTimeout(function() {
      f(val);
    }, ms * (i + 1));
  });
}

// Change 3000 -> 1000 * 60 * 5
setTimeouts(arr, 3000, output);

用一个 习俗 每个值的函数

var arr = ["a", "b", "c"];

function f1(val) {
  console.log("This is f1 with val: " + val);
}

function f2(val) {
  console.log("This is f2 with val: " + val);
}

function f3(val) {
  console.log("This is f3 with val: " + val);
}

function setTimeouts(arr, ms, fns) {
  arr.forEach(function(val, i) {
    setTimeout(function() {
      fns[i](val);
    }, ms * (i + 1));
  });
}

// Change 3000 -> 1000 * 60 * 5
setTimeouts(arr, 3000, [f1, f2, f3]);

从我收集的信息来看,您只希望每5分钟处理一个元素,直到最后一个元素被完全处理。我的建议是:

const ProcessListInInterval = (interval, list, callback) => {
  // Sets a delay for the element at the `index` position
  const setDelay = (index) => {
    // Only sets the delay if index < 0
    if (index < list.length) {
      setTimeout(() => {
        const element = list[index];
        // Process element
        callback(element);

        // Sets delay for the next index, you could potentially add code
        // to reset the index here, if you don't want this to ever stop
        setDelay(time, index + 1);
      }, interval);
    }
  };

  // Start from index 0
  setDelay(0);
};

ProcessListInInterval(300000 /* 5 * 60 * 1000 */, EveryTen, (element) => {
  // Do processing here
});

这可能和 setInterval 我也是,但我喜欢这样是因为三个原因:

1. ProcessListInInterval
3. 它是通用的和可重用的

我也是一个 functional programming 所以我更喜欢这种不变性+递归的风格。