DisposableStack.prototype.disposed — Eigenschaft · JavaScript-Referenz

Signatur

get DisposableStack.prototype.disposed

Beschreibung

Die Accessor-Eigenschaft disposed ist nur lesbar. Sie zeigt an, ob ein DisposableStack noch benutzt werden kann. Ein neu erzeugter Stapel hat den Wert false. Der Wert wechselt dauerhaft auf true, sobald eine dieser Aktionen eintritt:

Die Methode dispose() bzw. [Symbol.dispose]() wird aufgerufen.
Der Stapel wurde mit using deklariert und der umgebende Block wird verlassen. Dabei ruft die Laufzeit automatisch [Symbol.dispose]() auf.
Die Methode move() wird aufgerufen. Dabei gehen alle registrierten Ressourcen auf einen neuen Stapel über, und der alte Stapel gilt als aufgelöst.

Nützlich ist die Eigenschaft vor allem in Hilfsfunktionen, die einen Stapel von außen bekommen. Dort prüft man vor dem Aufruf von use(), adopt(), defer() oder move(), ob der Stapel noch gültig ist. Auf einem aufgelösten Stapel lösen diese Methoden nämlich einen ReferenceError aus.

Ein erneutes dispose() auf einem bereits aufgelösten Stapel ist dagegen erlaubt und bewirkt nichts. Die Eigenschaft hat keinen Setter. Eine Zuweisung wird im nicht-strikten Modus stillschweigend ignoriert und löst im strikten Modus einen TypeError aus.

Rückgabewert

Typ

boolean

Beschreibung

true, wenn der Stapel aufgelöst oder verschoben wurde, sonst false.

Beispiele

Zustand vor und nach dispose()

const stack = new DisposableStack();
stack.defer(() => console.log('Aufräumen …'));

console.log(stack.disposed);
stack.dispose();
console.log(stack.disposed);

// Zweiter Aufruf ist erlaubt, bewirkt aber nichts
stack.dispose();

false Aufräumen … true

move() macht den alten Stapel ungültig

const createConnections = () => {
  using stack = new DisposableStack();
  stack.defer(() => console.log('Verbindung A geschlossen'));
  stack.defer(() => console.log('Verbindung B geschlossen'));
  // Alles hat geklappt: Ressourcen an den Aufrufer übergeben
  const owned = stack.move();
  console.log('alt:', stack.disposed, '| neu:', owned.disposed);
  return owned;
};

const connections = createConnections();
connections.dispose();

alt: true | neu: false Verbindung B geschlossen Verbindung A geschlossen

Absichern vor weiterer Registrierung

const registerTimer = (stack, ms) => {
  if (stack.disposed) {
    console.warn('Stapel bereits aufgelöst – Timer wird nicht gestartet');
    return null;
  }
  const id = setInterval(() => {}, ms);
  stack.defer(() => clearInterval(id));
  return id;
};

const stack = new DisposableStack();
registerTimer(stack, 1000);
stack.dispose();
registerTimer(stack, 1000);

Stapel bereits aufgelöst – Timer wird nicht gestartet

Automatische Auflösung durch using

let ref;
{
  using stack = new DisposableStack();
  ref = stack;
  console.log('im Block:', ref.disposed);
}
console.log('nach dem Block:', ref.disposed);

im Block: false nach dem Block: true

// Wichtig · Fallstricke

Nur lesbar: Einen aufgelösten Stapel kann man nicht wieder aktivieren. Dafür braucht man einen neuen DisposableStack.
Fehler bei Weiterverwendung: use(), adopt(), defer() und move() lösen auf einem aufgelösten Stapel einen ReferenceError aus. dispose() dagegen nicht.
Falscher Empfänger: Wird der Getter mit einem this aufgerufen, das kein DisposableStack ist, entsteht ein TypeError, z. B. bei Object.getOwnPropertyDescriptor(DisposableStack.prototype, 'disposed').get.call({}). Für asynchrone Stapel gibt es eine eigene Eigenschaft: AsyncDisposableStack.prototype.disposed.
Fehler beim Aufräumen: disposed ist auch dann true, wenn ein Aufräum-Callback einen Fehler ausgelöst hat. Mehrere solche Fehler werden in einem SuppressedError zusammengefasst.
Kompatibilität: Die Eigenschaft gehört zum neuen Sprachmerkmal „Explicit Resource Management“. Sie wird ab Chrome/Edge 134, Firefox 134 und Node.js 24 unterstützt, in Safari derzeit noch nicht. Für ältere Umgebungen gibt es Polyfills, z. B. von core-js. Die Syntax using muss dann zusätzlich per Transpiler umgewandelt werden (Babel oder TypeScript 5.2+).

Siehe auch

DisposableStack DisposableStack.prototype.dispose() DisposableStack.prototype.move() DisposableStack.prototype.defer() AsyncDisposableStack.prototype.disposed using Symbol.dispose