DisposableStack.prototype.move()

Eingeschränkt verfügbar

Diese Funktion ist nicht Baseline, da sie in einigen der am weitesten verbreiteten Browser nicht funktioniert.

Die move()-Methode von Instanzen von DisposableStack erstellt eine neue DisposableStack-Instanz, die dieselben Disposer wie dieser Stack enthält, und markiert dann diesen Stack als entsorgt, ohne die Disposer aufzurufen.

In diesem Artikel

Syntax

move()

Parameter

Keine.

Rückgabewert

Eine neue DisposableStack-Instanz.

Ausnahmen

ReferenceError

Wird ausgelöst, wenn der Stack bereits entsorgt ist.

Beschreibung

Der Hauptzweck von move() besteht darin, die Verantwortung für die Entsorgung aus dem aktuellen Bereich zu übertragen. Beispielsweise kann Ihre Funktion das Eigentum an einigen Ressourcen beanspruchen und sie entsorgen, wenn ein Fehler auftritt; wenn alles erfolgreich abgeschlossen wird, geben Sie diese Ressourcen zurück und übertragen das Eigentum an den Aufrufer.

Wenn Sie move() verwenden, um das Eigentum zu übertragen, sollte der Aufruf von move() der letzte Schritt in Ihrem Kontrollfluss sein, da es keinen Besitzer zwischen dem Loslassen des Eigentums durch Ihren Code mit move() und dem Aufnehmen des Eigentums durch den Aufrufer aus dem Rückgabewert gibt.

js
let resource1;

function init() {
  using disposer = new DisposableStack();
  resource1 = disposer.use(getResource1());
  // ...
  // Drop ownership immediately before returning
  return disposer.move();
}

// Pick up ownership immediately after returning
using disposer = init();

js
let resource1;

function init() {
  using disposer = new DisposableStack();
  resource1 = disposer.use(getResource1());
  // ...
  const newDisposer = disposer.move();
  // If someone adds code in between these lines and an error occurs,
  // there would be no owner to free resource1
  return newDisposer;
}

using disposer = init();

Seien Sie auch vorsichtig bei folgendem Muster, obwohl in vielen Fällen die Verwendung des "guten" Musters sehr umständlich sein kann:

js
function init() {
  using disposer = new DisposableStack();
  const resource1 = disposer.use(getResource1());
  // ...
  return { disposer: disposer.move(), resource1 };
}

const { resource1, ...rest } = init();
// If someone adds code in between these lines and an error occurs,
// there would be no owner to free resource1
using disposer = rest.disposer;

move() kann auch für die konditionale Entsorgung verwendet werden, wenn Sie manchmal die Ressourcen überhaupt nicht entsorgen möchten. Zum Beispiel:

js
using disposer = new DisposableStack();
const server = disposer.use(makeServer());
await server.init();
if (server.ready) {
  // Successfully initialized server; it now should live through the rest
  // of the program. Drop its disposer and don't pick it up. It will no
  // longer be disposed at all.
  disposer.move();
}
// If we reach the end of the scope without running disposer.move(),
// then server isn't ready for any reason, and we dispose its resources
// by disposing the disposer.

Beispiele

Eigentum an einem Stack beanspruchen

js
function consumeStack(stack) {
  using newStack = stack.move(); // newStack now owns the disposers
  console.log(stack.disposed); // true
  console.log(newStack.disposed); // false
  // newStack is disposed here immediately before the function exits
}

const stack = new DisposableStack();
console.log(stack.disposed); // false
consumeStack(stack);
console.log(stack.disposed); // true

Ermöglichen, dass Ressourcen in zwei Codepfaden entsorgt werden

Der Hauptanwendungsfall von move() ist, wenn Sie eine oder mehrere Ressourcen haben, die entweder direkt hier entsorgt oder für die spätere Verwendung aufbewahrt werden sollen. In diesem Fall können Sie die Ressourcen in einen DisposableStack legen und move() aufrufen, wenn Sie die Ressourcen für die spätere Verwendung aufbewahren müssen.

js
class PluginHost {
  #disposed = false;
  #disposables;
  #channel;
  #socket;

  constructor() {
    // Create a DisposableStack that is disposed when the constructor exits.
    // If construction succeeds, we move everything out of `disposer` and into
    // `#disposables` to be disposed later.
    using disposer = new DisposableStack();

    // Create an IPC adapter around process.send/process.on("message").
    // When disposed, it unsubscribes from process.on("message").
    this.#channel = disposer.use(new NodeProcessIpcChannelAdapter(process));

    // Create a pseudo-websocket that sends and receives messages over
    // a NodeJS IPC channel.
    this.#socket = disposer.use(new NodePluginHostIpcSocket(this.#channel));

    // If we made it here, then there were no errors during construction and
    // we can safely move the disposables out of `disposer` and into `#disposables`.
    this.#disposables = disposer.move();

    // If construction failed, then `disposer` would be disposed before reaching
    // the line above. Event handlers would be removed, allowing `#channel` and
    // `#socket` to be GC'd.
  }

  [Symbol.dispose]() {
    if (this.#disposed) {
      return;
    }
    this.#disposed = true;
    // Put `this.#disposables` into a `using` variable, so it is automatically
    // disposed when the function exits.
    using disposables = this.#disposables;

    // NOTE: we can free `#socket` and `#channel` here since they will be
    // disposed by the call to `disposables[Symbol.dispose]()`, below.
    // This isn't strictly a requirement for every disposable, but is
    // good housekeeping since these objects will no longer be useable.
    this.#socket = undefined;
    this.#channel = undefined;
    this.#disposables = undefined;
  }
}

Help improve MDN

War diese Übersetzung hilfreich?

Ja Nein

Erfahren Sie, wie Sie beitragen können Diese Seite wurde automatisch aus dem Englischen übersetzt.

Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden

Eingebaute Standardobjekte
DisposableStack
Konstruktor
1. DisposableStack()
Instanzmethoden
Instanzeigenschaften
1. disposed
Vererbung
Object/Function
Statische Methoden
Statische Eigenschaften
Instanzmethoden
Instanzeigenschaften
1. __proto__
2. constructor