Porównaj ceny domen i usług IT, sprzedawców z całego świata

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


Istnieje sposób na skonfigurowanie metody
setInterval
z poziomu javascript w celu natychmiastowego wykonania metody, a następnie wykonania jej z zegarem
Zaproszony:
Anonimowy użytkownik

Anonimowy użytkownik

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

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

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

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

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

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

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

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

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

Anonimowy użytkownik

Potwierdzenie od:

<div class="snippet-code">
<div class="snippet" data-hide="false" data-lang="js">
<pre class="snippet-code-js lang-js prettyprint-override">
// 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

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

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

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

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

Aby odpowiedzieć na pytania, Zaloguj się lub Zarejestruj się