I want to be able to call setInterval (or something similar) at two different lengths, alternating.

For example, running a function after 5 seconds, then 1 second, then 5 seconds again, and so on.

Is this possible? I tried a function that alternates the value, but it didn't seem to work.

let num = 5000

function alternateNum() {
  if (num === 5000) { num = 1000 }
  else { num = 5000 }
}

setInterval(() => {
  // ...

  alternateNum()
}, num);

CodePudding user response：

The problem with setInterval() is that the time is taken into account just once. You can use setTimeout() with recursion instead:

function doAction(flipFlop) {
  setTimeout(() => {
    console.log(flipFlop ? 'flip' : 'flop');
    doAction(!flipFlop);
    // do some other action...
  }, flipFlop ? 1000 : 3000);
}

doAction(true);

Watch out though if you have a long running process, this recursion gets deeper and deeper.

CodePudding user response：

I think this method is the easiest:

setInterval(() => {
    console.log("first");
    setTimeout(() => console.log("second"), 750);
}, 2000);

This creates an interval that alternates between 1250 and 750 milliseconds.

CodePudding user response：

The problem with your code

let num = 5000

function alternateNum() {
  if (num === 5000) { num = 1000 }
  else { num === 5000 }
}

setInterval(() => {
  // ...
  alternateNum()
}, num);

The last few lines (the setInterval) call are only getting called once with the initial value of num and thus any future changes to num won't be reflected in the setTimeout call.

How to fix it

You should use setTimeout within the function that has your code and call your function recursively:

const doStuff = (time = 1000) => {
    // Your code here

    // generate the next time to wait
    const nextTime = time === 5000 ? 1000 : 5000;
    // call the function again after waiting `time` milliseconds
    setInterval(() => doStuff(nextTime), time);
}

Then you would call doStuff to start it. If you wanted to start it immediately with the next one happening after 1 second you could do:

doStuff();

Or if you wanted to call it after 5 seconds with the next one happening one second after that:

setTimeout(doStuff, 5000);

The difference here compared to your code is that the variable that represents the time is being used over and over again as it changes instead of just once on initial code execution.

CodePudding user response：

JS timers have a very complicated history.

Using a recursive setTimeout invocation is a simple and elegant solution as long (as your runtime implements tail call optimization).

Separate from the issue of recursion is the issue of timer drift. This is covered in the YouTube video JavaScript counters the hard way - HTTP 203 if you'd like an accessible introduction.

In many JS engines (e.g. V8) setInterval will handle drift correction for you, so there's actually an advantage to using it over recursively invoking setTimeout. (Check the millisecond timestamps in the console messages in the snippet below to verify this.)

In order to determine the constant interval argument you'll need for setInterval, you'll need to find the greatest common factor of your delay durations. Once you have this value, you can use it as the base interval delay, and keep track of your interval state to determine whether you should switch to the next interval delay, run your other code, etc. Here's a minimal example:

const durations = [1000, 5000];

// If you can't determine this in advance and use a constant value,
// then you can calculate it at runtime using a function:
const gcf = 1000; // or const gcf = findGreatestCommonFactor(durations);

let durationIndex = 0;
let elapsed = 0;

function update () {
  elapsed  = gcf;
  const ready = elapsed === durations[durationIndex];
  if (ready) {
    elapsed = 0;
    durationIndex = (durationIndex   1) % durations.length;
  }
  return ready;
}

setInterval(() => {
  const ready = update();
  if (!ready) return;

  // Do your interval task, for example:
  console.log('tick');
}, gcf);