javascript - Kör setInterval-funktionen utan fördröjning första gången

Finns det ett sätt att konfigurera setInterval-metoden i JavaScript för att köra metoden omedelbart och sedan köra den med timern

Svar #1

Det är enklast att helt enkelt kalla på funktionen själv direkt första gången:

foo();
setInterval(foo, delay);

Det finns dock goda skäl att undvika setInterval - särskilt i vissa situationer kan en hel mängd setInterval-händelser anlända direkt efter varandra utan någon fördröjning. En annan anledning är att om du vill stoppa loopen måste du uttryckligen anropa clearInterval, vilket innebär att du måste komma ihåg handtaget som returnerades från det ursprungliga setInterval-anropet.

Så ett alternativt sätt är att låta foo trigga sig själv för efterföljande anrop med setTimeout istället:

function foo() {
   // do stuff
   // ...

   // and schedule a repeat
   setTimeout(foo, delay);
}

// start the cycle
foo();

Detta garanterar att det finns åtminstone ett intervall på delay mellan anrop. Det gör det också enklare att avbryta loopen om det behövs - du behöver bara inte anropa setTimeout när ditt loopavslutningsvillkor uppnås.

Ännu bättre, du kan slå in allt detta i ett omedelbart anropat funktionsuttryck som skapar funktionen, som sedan anropar sig själv igen som ovan, och automatiskt startar loopen:

(function foo() {
    ...
    setTimeout(foo, delay);
})();

som definierar funktionen och startar cykeln allt på en gång.

Svar #2

Jag är inte säker på om jag förstår dig rätt, men du skulle enkelt kunna göra något som detta:

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

Det finns uppenbarligen många sätt att göra detta på, men det är det mest kortfattade sättet jag kan komma på.

Svar #3

Jag snubblade över den här frågan på grund av samma problem, men inget av svaren hjälper om du behöver agera exakt som setInterval() men med den endast skillnaden att funktionen kallas omedelbart i början.

Här är min lösning på detta problem:

function setIntervalImmediately(func, interval) {
  func();
  return setInterval(func, interval);
}

Fördelen med den här lösningen:

  • befintlig kod som använder setInterval kan enkelt anpassas genom substitution
  • fungerar i strikt läge
  • det fungerar med befintliga namngivna funktioner och closures
  • du kan fortfarande använda returvärdet och skicka det till clearInterval() senare

Exempel :

// create 1 second interval with immediate execution
var myInterval = setIntervalImmediately( _ => {
        console.log('hello');
    }, 1000);

// clear interval after 4.5 seconds
setTimeout( _ => {
        clearInterval(myInterval);
    }, 4500);

För att vara kaxig, om du verkligen behöver använda setInterval så kan du också ersätta den ursprungliga setInterval. Därför krävs ingen ändring av koden när du lägger till detta före din befintliga kod:

var setIntervalOrig = setInterval;

setInterval = function(func, interval) {
    func();
    return setIntervalOrig(func, interval);
}

Ändå gäller alla fördelar som nämnts ovan här, men ingen ersättning är nödvändig.

Svar #4

Du kan omsluta setInterval() i en funktion som tillhandahåller det beteendet:

function instantGratification( fn, delay ) {
    fn();
    setInterval( fn, delay );
}

...använd det sedan så här:

instantGratification( function() {
    console.log( 'invoked' );
}, 3000);

Relaterade artiklar