对于那些使用React的人，下面是我解决这个问题的方法:

const intervalRef = useRef(0);

useEffect(() => {
    if (condition is true){
        if (intervalRef.current === 0) {
            callMyFunction();
        }
        const interval = setInterval(() => {
            callMyFunction();
        }, 5_000);
        intervalRef.current = interval;
    } else {
        clearInterval(intervalRef.current);
    }
}, [deps]);

你可以在函数中设置一个非常小的初始延迟时间(例如100)，并将其设置为你想要的延迟时间:

Var延迟= 100; 函数foo() { console.log("改变初始延迟时间为你想要的。"); 延迟= 12000; setTimeout (foo,延迟); ｝

如果你可以使用RxJS，有一个叫做timer()的东西:

import { Subscription, timer } from 'rxjs';

const INITIAL_DELAY = 1;
const INTERVAL_DELAY = 10000;
const timerSubscription = timer(INITIAL_DELAY, INTERVAL_DELAY)
  .subscribe(() => {
    this.updateSomething();
  });

// when destroying
timerSubscription.unsubscribe();

这个例子建立在@Alnitak的回答上，但是使用await Promise在循环循环中进行更细粒度的控制。

比较的例子:

let stillGoing = true;

(function foo() {
    console.log('The quick brown fox did its thing');
    if (stillGoing) setTimeout(foo, 5000);
})();

foo();

在上面的例子中，我们调用foo()，然后它每5秒调用一次自己。

但是如果，在未来的某个时候，我们为了停止循环而将stillGoing设为false，即使在发出停止命令之后，我们仍然会得到一个额外的log行。这是因为在任何给定的时间，在我们将stillGoing设置为false之前，当前迭代将已经创建了一个超时来调用下一次迭代。

如果我们使用await Promise作为延迟机制，那么我们就有机会在调用下一次迭代之前停止循环:

let stillGoing = true;

(async function foo() {
    console.log('The quick brown fox did its thing');
    await new Promise(resolve => setTimeout(resolve, 5000));
    if (stillGoing) foo();
})();

foo();

在第二个示例中，我们首先设置5000ms的延迟，之后检查stillGoing值并决定是否调用另一个递归是合适的。

如果我们在任意点将stillGoing设为false，在我们设置值之后就不会打印出额外的log行。

需要注意的是，这要求函数是异步的，对于给定的使用，这可能是也可能不是一个选项。

为了解决这个问题，我在页面加载后第一次运行这个函数。

function foo(){ ... }

window.onload = function() {
   foo();
};

window.setInterval(function()
{
    foo(); 
}, 5000);

我不确定我是否理解正确，但你可以很容易地做这样的事情:

setInterval(function hello() {
  console.log('world');
  return hello;
}(), 5000);

显然有很多方法可以做到这一点，但这是我能想到的最简洁的方法。