WorkerGlobalScope.setInterval() — Methode · JavaScript-Referenz

Signatur

WorkerGlobalScope.setInterval(func, delay, ...args)

Beschreibung

setInterval() ist im globalen Gültigkeitsbereich jedes Workers (DedicatedWorkerGlobalScope, SharedWorkerGlobalScope, ServiceWorkerGlobalScope) verfügbar und verhält sich wie das Gegenstück Window.setInterval() im Hauptthread. Die übergebene Funktion wird alle delay Millisekunden erneut in die Ereignisschleife des Workers eingereiht, bis das Intervall mit clearInterval() beendet oder der Worker terminiert wird.

Typische Einsatzzwecke im Worker sind periodisches Polling eines Servers per fetch(), regelmäßige Fortschrittsmeldungen an den Hauptthread über postMessage(), Heartbeats für WebSocket-Verbindungen oder zeitgesteuerte Hintergrundberechnungen. Da der Worker in einem eigenen Thread läuft, blockieren diese Aufgaben die Benutzeroberfläche nicht.

Der Aufruf erfolgt meist ohne Präfix (setInterval(...)) oder explizit über self.setInterval(...). Die zurückgegebene ID ist nur innerhalb desselben Workers gültig – ein Intervall im Worker kann also nicht vom Hauptthread aus mit clearInterval() gestoppt werden; dafür muss eine Nachricht an den Worker geschickt werden.

Parameter

Name	Typ	Default	Beschreibung
$func Pflicht	Function \| string		Die Funktion, die bei jedem Intervall ausgeführt wird. Alternativ ein Code-String, der wie bei `eval()` ausgewertet wird (nicht empfohlen).
$delay	number	0	Zeitabstand zwischen den Aufrufen in Millisekunden. Werte unter 0 werden als 0 behandelt; sehr kleine Werte werden vom Browser gedrosselt (mind. ca. 4 ms bei verschachtelten Timern).
$...args	any		Zusätzliche Argumente, die bei jedem Aufruf an `func` übergeben werden.

Rückgabewert

Typ

number

Beschreibung

Eine positive Ganzzahl (Interval-ID ungleich 0), die das Intervall eindeutig im aktuellen Worker identifiziert und an clearInterval() übergeben werden kann.

Beispiele

Fortschritt periodisch an den Hauptthread melden

// worker.js
let fortschritt = 0;

const id = setInterval(() => {
  fortschritt += 10;
  self.postMessage({ typ: 'fortschritt', wert: fortschritt });

  if (fortschritt >= 100) {
    clearInterval(id);
    self.postMessage({ typ: 'fertig' });
  }
}, 500);

// main.js
const worker = new Worker('worker.js');
worker.onmessage = ({ data }) => console.log(data);

{ typ: 'fortschritt', wert: 10 } { typ: 'fortschritt', wert: 20 } ... { typ: 'fortschritt', wert: 100 } { typ: 'fertig' }

Server-Polling per Nachricht starten und stoppen

// worker.js
let pollId = null;

const pruefeStatus = async (url) => {
  try {
    const res = await fetch(url);
    const status = await res.json();
    self.postMessage(status);
  } catch (err) {
    self.postMessage({ fehler: err.message });
  }
};

self.addEventListener('message', ({ data }) => {
  if (data.befehl === 'start' && pollId === null) {
    // Zusatzargument url wird an pruefeStatus übergeben
    pollId = setInterval(pruefeStatus, 5000, data.url);
  } else if (data.befehl === 'stop') {
    clearInterval(pollId);
    pollId = null;
  }
});

// main.js
const worker = new Worker('worker.js');
worker.postMessage({ befehl: 'start', url: '/api/status' });
// später:
// worker.postMessage({ befehl: 'stop' });

Drift vermeiden mit rekursivem setTimeout

// worker.js – garantiert Pause NACH Abschluss der asynchronen Arbeit
const tick = async () => {
  const start = performance.now();
  await fetch('/api/heartbeat', { method: 'POST' });
  console.log(`Heartbeat in ${Math.round(performance.now() - start)} ms`);
  setTimeout(tick, 10000);
};

tick();

Heartbeat in 42 ms

// Wichtig · Fallstricke

Kein festes Timing: setInterval() garantiert keinen exakten Abstand. Ist der Worker beschäftigt, verzögern sich Aufrufe; lang laufende Callbacks können zu Drift führen. Bei asynchroner Arbeit (z. B. fetch()) können sich Aufrufe überlappen – rekursives setTimeout() ist dann oft robuster.
Immer aufräumen: Nicht gestoppte Intervalle halten den Worker aktiv und verbrauchen Ressourcen. Mit clearInterval(id) beenden; worker.terminate() oder self.close() beendet alle Timer.
Service Worker: Service Worker werden vom Browser nach kurzer Inaktivität beendet – Intervalle darin sind unzuverlässig. Für periodische Aufgaben besser Periodic Background Sync oder Push verwenden.
Sicherheit: Die String-Variante (setInterval("code", 1000)) wertet Code wie eval() aus, wird durch eine CSP ohne 'unsafe-eval' blockiert und birgt Injektionsrisiken. Immer eine Funktion übergeben.
Drosselung: Ab einer Verschachtelungstiefe von 5 wird die Mindestverzögerung auf ca. 4 ms angehoben; Verzögerungen über 2³¹−1 ms (ca. 24,8 Tage) laufen über und führen zu sofortiger Ausführung.
this: Innerhalb einer normalen Callback-Funktion verweist this auf den globalen Worker-Scope, nicht auf ein umgebendes Objekt – Pfeilfunktionen oder bind() verwenden.
Kompatibilität: In allen modernen Browsern sowie in Deno/Bun-Workern unterstützt; in Node.js worker_threads existiert eine eigene Timer-Implementierung, die ein Timeout-Objekt statt einer Zahl zurückgibt.

Siehe auch

WorkerGlobalScope.clearInterval() WorkerGlobalScope.setTimeout() Window.setInterval() WorkerGlobalScope DedicatedWorkerGlobalScope.postMessage() Worker WorkerGlobalScope.dump()