Performance.memory — Eigenschaft · JavaScript-Referenz

Signatur

get Performance.memory

Beschreibung

Die Eigenschaft performance.memory gibt ein Objekt mit drei Kennzahlen zum JavaScript-Heap der aktuellen Seite zurück. Damit lässt sich grob abschätzen, wie viel Speicher eine Webanwendung belegt, und ob er mit der Zeit wächst, etwa durch ein Speicherleck.

jsHeapSizeLimit: die maximale Heap-Größe in Bytes, die dem Kontext zur Verfügung steht.
totalJSHeapSize: die aktuell reservierte Heap-Größe in Bytes.
usedJSHeapSize: der tatsächlich von JavaScript-Objekten belegte Teil des Heaps in Bytes.

Die Eigenschaft ist kein Webstandard und gibt es nur in Chromium-basierten Browsern. Firefox und Safari kennen sie nicht. Die Werte werden absichtlich ungenau gemacht (quantisiert) und nur in Abständen aktualisiert, damit sich darüber keine Informationen zwischen Ursprüngen abgreifen lassen. Für Diagnose und Entwicklung reicht das trotzdem, zum Beispiel um in Dashboards einen Trend zu erkennen.

Der standardisierte Nachfolger ist performance.measureUserAgentSpecificMemory(). Diese Methode liefert ein Promise und steht nur in cross-origin-isolierten Kontexten zur Verfügung. Neuer Code sollte sie bevorzugen und performance.memory höchstens als Rückfallebene verwenden.

Rückgabewert

Typ

MemoryInfo | undefined

Beschreibung

Ein MemoryInfo-Objekt mit den Zahlenwerten jsHeapSizeLimit, totalJSHeapSize und usedJSHeapSize, jeweils in Bytes. In Browsern ohne Unterstützung ist der Wert undefined.

Beispiele

Heap-Kennzahlen mit Funktionsprüfung auslesen

const toMB = (bytes) => (bytes / 1024 / 1024).toFixed(1) + ' MB';

if (performance.memory) {
  const { usedJSHeapSize, totalJSHeapSize, jsHeapSizeLimit } = performance.memory;
  console.log('Belegt:', toMB(usedJSHeapSize));
  console.log('Reserviert:', toMB(totalJSHeapSize));
  console.log('Limit:', toMB(jsHeapSizeLimit));
} else {
  console.log('performance.memory wird von diesem Browser nicht unterstützt.');
}

Belegt: 12.4 MB Reserviert: 18.0 MB Limit: 4096.0 MB

Speicherverbrauch regelmäßig überwachen (Leck-Suche)

const samples = [];

const sample = () => {
  if (!performance.memory) return;
  samples.push({
    zeit: Math.round(performance.now()),
    belegt: performance.memory.usedJSHeapSize
  });
  // Nur die letzten 60 Messpunkte behalten
  if (samples.length > 60) samples.shift();

  const erster = samples[0].belegt;
  const letzter = samples.at(-1).belegt;
  const wachstum = ((letzter - erster) / erster) * 100;
  if (samples.length === 60 && wachstum > 50) {
    console.warn(`Heap um ${wachstum.toFixed(0)} % gewachsen – mögliches Speicherleck?`);
  }
};

const timerId = setInterval(sample, 5000);
// Später stoppen: clearInterval(timerId);

Heap um 63 % gewachsen – mögliches Speicherleck?

Standardisierte API bevorzugen, performance.memory als Rückfall

const getMemoryUsage = async () => {
  if (crossOriginIsolated && 'measureUserAgentSpecificMemory' in performance) {
    const result = await performance.measureUserAgentSpecificMemory();
    return { quelle: 'standard', bytes: result.bytes };
  }
  if (performance.memory) {
    return { quelle: 'legacy', bytes: performance.memory.usedJSHeapSize };
  }
  return { quelle: 'keine', bytes: null };
};

const usage = await getMemoryUsage();
console.log(usage);

{ quelle: 'legacy', bytes: 13003776 }

// Wichtig · Fallstricke

Nicht standardisiert und veraltet: Die Eigenschaft gibt es nur in Chromium (Chrome, Edge, Opera). In Firefox und Safari ist sie undefined. Deshalb vor dem Zugriff immer prüfen, ob sie vorhanden ist.
Ungenaue Werte: Aus Sicherheitsgründen (Seitenkanal-Angriffe) werden die Werte gerundet und nur verzögert aktualisiert. Nur wenn Chrome mit --enable-precise-memory-info gestartet wird, sind sie genau. Für Mikro-Benchmarks taugen die Werte nicht.
Nur der JS-Heap: DOM-Knoten, Bilder, Canvas-Puffer, WebAssembly-Speicher und Speicher anderer Frames oder Worker werden nicht oder nur teilweise erfasst. Die Werte zeigen also nicht den gesamten Speicherverbrauch des Tabs.
Garbage Collection: usedJSHeapSize schwankt stark, je nachdem, wann die Speicherbereinigung läuft. Aussagekräftig sind nur Trends über längere Zeiträume.
TypeScript: memory fehlt in den Standard-Typdefinitionen (lib.dom.d.ts). Nötig ist dann eine eigene Typerweiterung oder ein Typecast.
Nachfolger: performance.measureUserAgentSpecificMemory() setzt Cross-Origin-Isolation voraus, also die Header COOP: same-origin und COEP: require-corp.

Siehe auch

Performance Performance.now() PannerNode.positionY PerformanceEntry.entryType Performance.timing