TaskController

Konstruktor

TaskController()

Erstellt ein neues TaskController-Objekt. Dabei kann optional die Priorität des zugehörigen signal angegeben werden.

Instanzeigenschaften

Diese Schnittstelle erbt außerdem die Eigenschaften ihrer übergeordneten Schnittstelle AbortController.

TaskController.signal Schreibgeschützt

Gibt eine TaskSignal-Objektinstanz zurück. Das Signal wird an Tasks übergeben, damit der Controller sie abbrechen oder ihre Priorität ändern kann. Die Eigenschaft wird von AbortController geerbt.

Instanzmethoden

Diese Schnittstelle erbt außerdem die Methoden ihrer übergeordneten Schnittstelle AbortController.

TaskController.setPriority()

Legt die Priorität des signal des Controllers fest und damit auch die Priorität aller zugehörigen Tasks. Beobachter werden über die Prioritätsänderung benachrichtigt, indem ein prioritychange-Ereignis ausgelöst wird.

Beispiele

Zunächst erstellen wir einen Task-Controller und setzen die Priorität des zugehörigen Signals auf user-blocking.

// Create a TaskController, setting its signal priority to 'user-blocking'
const controller = new TaskController({ priority: "user-blocking" });

Anschließend fügen wir einen Event-Listener für prioritychange-Ereignisse hinzu (hier wird addEventListener() aufgerufen; alternativ könnten wir TaskSignal.onprioritychange einen Handler zuweisen). Der Handler verwendet previousPolicy auf dem Ereignis, um die ursprüngliche Priorität zu ermitteln, und TaskSignal.priority auf dem Ereignisziel, um die neue Priorität zu ermitteln.

// Listen for 'prioritychange' events on the controller's signal.
controller.signal.addEventListener("prioritychange", (event) => {
  const previousPriority = event.previousPriority;
  const newPriority = event.target.priority;
  console.log(`Priority changed from ${previousPriority} to ${newPriority}.`);
});

Wie unten gezeigt, können wir auch auf abort-Ereignisse reagieren. Denselben Ansatz würden wir verwenden, wenn der Controller ein AbortController wäre.

controller.signal.addEventListener(
  "abort",
  (event) => {
    console.log("Task aborted");
  },
  { once: true },
);

Als Nächstes planen wir den Task ein und übergeben das Signal des Controllers als optionales Argument. In diesem Fall ist der Task lediglich eine Pfeilfunktion, die das Promise durch die Rückgabe eines Textes erfüllt. Mit then und catch behandeln wir, ob der Task erfolgreich abgeschlossen oder zurückgewiesen wird, und protokollieren jeweils den zurückgegebenen Text oder den Fehler. Beachten Sie, dass wir den Task in einem späteren Codeblock abbrechen. Daher wird tatsächlich nur der catch()-Block ausgeführt!

// Post task using the controller's signal.
// The signal priority sets the initial priority of the task
scheduler
  .postTask(() => "Task execute", { signal: controller.signal })
  .then((taskResult) => {
    console.log(`${taskResult}`);
  }) // Aborted (won't run)
  .catch((error) => {
    console.log(`Catch error: ${error}`);
  }); // Log error

Mit dem Controller können wir den Task verwalten. Hier können wir die Priorität mit TaskController.setPriority() ändern. Dadurch wird das zugehörige prioritychange-Ereignis ausgelöst.

// Change the priority to 'background' using the controller
controller.setPriority("background");

Schließlich kann der Task durch einen Aufruf von abort() auf dem Controller abgebrochen werden.

// Abort the task
controller.abort();

Die Konsolenausgabe dieses Beispiels wäre:

The priority changed from user-blocking to background.
Task aborted
Catch error: AbortError

Spezifikationen

Browser-Kompatibilität