Uruchom funkcję setInterval bez opóźnienia za pierwszym razem

Potwierdzenie od:

Najłatwiej jest po prostu wywołać funkcję bezpośrednio za pierwszym razem:

foo();

setInterval(foo, delay);

Istnieją jednak dobre powody, aby unikać

setInterval

- w szczególności w niektórych okolicznościach całe obciążenie zdarzeń

setInterval

może nadejść natychmiast po sobie bez żadnych opóźnień. Innym powodem jest to, że jeśli chcesz zatrzymać pętlę, musisz jawnie wywołać

clearInterval

, co oznacza, że musisz zapamiętać deskryptor zwrócony z pierwotnego wywołania

setInterval

.
Zatem alternatywną metodą jest wyzwalanie

foo

samego siebie dla kolejnych wywołań, używając zamiast tego

setTimeout

:

function foo() {

// do stuff

// ...// and schedule a repeat

 setTimeout(foo, delay);

}// start the cycle

foo();

To gwarantuje, że tak jest

przynajmniej

najmniejszy odstęp

opóźnienia

między połączeniami. Ułatwia również anulowanie pętli w razie potrzeby - po prostu nie wywołujesz

setTimeout

, gdy zostanie osiągnięty warunek końcowy.
Jeszcze lepiej, możesz to wszystko opakować

natychmiast nazywany wyrażeniem funkcyjnym

który tworzy funkcję, która następnie wywołuje siebie ponownie, jak opisano powyżej, i automatycznie uruchamia pętlę:

(function foo() {

 ...

 setTimeout(foo, delay);

})();

który definiuje funkcję i uruchamia pętlę za jednym razem.

Anonimowy użytkownik

Potwierdzenie od:

Nie jestem pewien, czy dobrze Cię rozumiem, ale możesz łatwo zrobić coś takiego:

setInterval(function hello() {

 console.log('world');

 return hello;

}(), 5000);

Oczywiście jest na to wiele sposobów, ale jest to najkrótszy sposób, jaki przychodzi mi do głowy.

Anonimowy użytkownik

Potwierdzenie od:

Natknąłem się na to pytanie z powodu tego samego problemu, ale żadna z odpowiedzi nie pomaga, jeśli potrzebujesz

zachowywać się dokładnie

to samo co

setInterval ()

, ale z tym

tylko

różnica polega na tym, że funkcja jest wywoływana natychmiast na początku.
Oto moje rozwiązanie tego problemu:

function setIntervalImmediately(func, interval) {

 func();

 return setInterval(func, interval);

}

Zaleta tego rozwiązania:

istniejący kod wykorzystujący
```
setInterval
```
można łatwo dostosować, zastępując go
działa w trybie ścisłym
działa z istniejącymi nazwanymi funkcjami i zamknięciami
nadal możesz użyć wartości zwracanej i przekazać ją później do
```
clearInterval ()
```

Przykład:

// create 1 second interval with immediate execution

var myInterval = setIntervalImmediately( _ => {

 console.log('hello');

 }, 1000);// clear interval after 4.5 seconds

setTimeout( _ => {

 clearInterval(myInterval);

 }, 4500);

Aby być zarozumiałym, jeśli naprawdę potrzebujesz użyć

setInterval

, możesz także zastąpić oryginalny

setInterval

. Dlatego dodanie tego kodu przed istniejącym nie wymaga żadnych zmian w kodzie:

var setIntervalOrig = setInterval;setInterval = function(func, interval) {

 func();

 return setIntervalOrig(func, interval);

}

Jednak wszystkie wymienione powyżej świadczenia mają tutaj zastosowanie, ale wymiana nie jest wymagana.

Anonimowy użytkownik

Potwierdzenie od:

Możesz opakować

setInterval ()

w funkcję, która zapewnia takie zachowanie:

function instantGratification( fn, delay ) {

 fn();

 setInterval( fn, delay );

}

...
następnie użyj tego w ten sposób:

instantGratification( function() {

 console.log( 'invoked' );

}, 3000);

Anonimowy użytkownik

Potwierdzenie od:

Oto okładka, którą możesz wytrzeć, jeśli jej potrzebujesz:

(function() {

 var originalSetInterval = window.setInterval; window.setInterval = function(fn, delay, runImmediately) {

 if(runImmediately) fn();

 return originalSetInterval(fn, delay);

 };

})();

Ustaw trzeci argument na setInterval na true, a zadziała to za pierwszym razem zaraz po wywołaniu setInterval:

setInterval(function() { console.log("hello world"); }, 5000, true);

Lub pomiń trzeci argument, a zachowa swoje pierwotne zachowanie:

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

Niektóre przeglądarki obsługują

dodatkowe argumenty
https://developer.mozilla.org/ ... erval
dla setInterval, które to opakowanie ignoruje; Myślę, że są rzadko używane, ale miej to na uwadze, jeśli naprawdę ich potrzebujesz.

Anonimowy użytkownik

Potwierdzenie od:

Zasugeruję wywołanie funkcji w następującej kolejności

var _timer = setInterval(foo, delay, params);

foo(params)

Możesz też zdać
_timer

w foo, jeśli chcesz, aby

clearInterval (_timer)

pod pewnymi warunkami

var _timer = setInterval(function() { foo(_timer, params) }, delay);

foo(_timer, params);

Anonimowy użytkownik

Potwierdzenie od:

Ktoś musi rzutować zewnętrzne

this

do wewnątrz, tak jak jest to funkcja strzałki.

(function f() {

 this.emit("...");

 setTimeout(f.bind(this), 1000);

}).bind(this)();

Jeśli powyższe generowanie śmieci przeszkadza Ci, możesz zamiast tego wykonać zamknięcie.

(that => {

 (function f() {

 that.emit("...");

 setTimeout(f, 1000);

 })();

})(this);

A może rozważ użycie

@autobind

decorator
https://www.npmjs.com/package/autobind-decorator
w zależności od twojego kodu.

Anonimowy użytkownik

Potwierdzenie od:

Oto prosta wersja dla początkujących bez zamieszania. Po prostu deklaruje funkcję, wywołuje ją, a następnie rozpoczyna interwał. To wszystko.
<div class="snippet-code">
<div class="snippet" data-babel="false" data-console="true" data-hide="false" data-lang="js">
<pre class="snippet-code-js lang-js prettyprint-override">

//Declare your function here

function My_Function(){

 console.log("foo");

}//Call the function first

My_Function();//Set the interval

var interval = window.setInterval( My_Function, 500 );

Anonimowy użytkownik

Potwierdzenie od:

Aby rozwiązać ten problem, uruchamiam tę funkcję po raz pierwszy po załadowaniu strony.

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

 foo();

};window.setInterval(function()

{

 foo(); 

}, 5000);

Anonimowy użytkownik

Potwierdzenie od:

// YCombinator

function anonymous(fnc) {

 return function() {

 fnc.apply(fnc, arguments);

 return fnc;

 }

}// Invoking the first time:

setInterval(anonymous(function() {

 console.log("bar");

})(), 4000);// Not invoking the first time:

setInterval(anonymous(function() {

 console.log("foo");

}), 4000);

// Or simple:

setInterval(function() {

 console.log("baz");

}, 4000);

Anonimowy użytkownik

Potwierdzenie od:

Istnieje przydatny pakiet npm o nazwie

firstInterval
https://www.npmjs.com/package/first-interval
(pełne ujawnienie, to jest moje).
Wiele przykładów tutaj nie obejmuje obsługi parametrów, a zmiana domyślnego zachowania

setInterval

w każdym dużym projekcie jest zła. Z dokumentów:
Ten szablon

setInterval(callback, 1000, p1, p2);

callback(p1, p2);

identyczny z

firstInterval(callback, 1000, p1, p2);

Jeśli jesteś oldschoolowy w przeglądarce i nie chcesz zależności, jest to prosta metoda „wytnij i wklej”

kod.
https://github.com/jimm101/firstInterval

Anonimowy użytkownik

Potwierdzenie od:

Możesz ustawić bardzo mały początkowy czas opóźnienia (np. 100) i ustawić go na żądany czas opóźnienia wewnątrz funkcji:
<div class="snippet-code">
<div class="snippet" data-babel="false" data-console="true" data-hide="false" data-lang="js">
<pre class="snippet-code-js lang-js prettyprint-override">

var delay = 100;function foo() {

 console.log("Change initial delay-time to what you want.");

 delay = 12000;

 setTimeout(foo, delay);

}

Anonimowy użytkownik

Potwierdzenie od:

Występuje problem z natychmiastowym wywołaniem funkcji asynchronicznie, ponieważ standardowy setTimeout/setInterval ma minimalny limit czasu wynoszący około kilku milisekund, nawet jeśli ustawisz go bezpośrednio na 0. Jest to spowodowane określonym zachowaniem przeglądarki.
Przykład PRAWDZIWEGO kodu z zerowym opóźnieniem, który działa w Chrome, Safari, Opera

function setZeroTimeout(callback) {

var channel = new MessageChannel();

channel.port1.onmessage = callback;

channel.port2.postMessage('');

}

Więcej informacji można znaleźć

tutaj
http://ajaxian.com/archives/settimeout-delay
Po pierwszym ręcznym wywołaniu możesz utworzyć interwał za pomocą swojej funkcji.

Anonimowy użytkownik

Potwierdzenie od:

właściwie najszybciej to zrobić

interval = setInterval(myFunction(),45000)

to wywoła moją funkcję, a następnie będzie to robić co 45 sekund, co różni się od robienia

interval = setInterval(myfunction, 45000)

co nie zadzwoni, ale tylko zaplanuje

Uruchom funkcję setInterval bez opóźnienia za pierwszym razem

14 odpowiedzi

Powiązane pytanie

Stan problemu

Uruchom funkcję setInterval bez opóźnienia za pierwszym razem

Linki dotyczące treści

14 odpowiedzi

Powiązane pytanie

Stan problemu