Start · Sprachen · JavaScript · Referenz · FileSystemSyncAccessHandle.getSize()

FileSystemSyncAccessHandle.getSize()

Methode

Gibt synchron die aktuelle Größe der mit dem <code>FileSystemSyncAccessHandle</code> verbundenen Datei in Bytes zurück.

seit JavaScript Baseline 2023: Chrome 108+, Edge 108+, Firefox 111 Kategorie: webapi

Signatur

FileSystemSyncAccessHandle.prototype.getSize()

Beschreibung

Die Methode getSize() liefert die aktuelle Länge einer Datei im Origin Private File System (OPFS) in Bytes. Sie gehört zu FileSystemSyncAccessHandle. Ein solches Handle erhält man über FileSystemFileHandle.createSyncAccessHandle(). Es erlaubt schnelle, synchrone Lese- und Schreibzugriffe und ist deshalb vor allem für rechenintensive Anwendungen wie SQLite-WASM, Datenbanken oder Editoren gedacht.

Man braucht getSize() typischerweise, um einen Puffer passender Größe für read() anzulegen, um Daten am Dateiende anzuhängen (write(data, { at: size })) oder um vor truncate() die Länge zu prüfen. Der Wert zeigt immer den aktuellen Stand, auch nach Schreibvorgängen, die noch nicht mit flush() auf den Datenträger geschrieben wurden.

Wie alle Methoden von FileSystemSyncAccessHandle ist getSize() nur in dedizierten Web Workern verfügbar, nicht im Hauptthread und nicht in Shared oder Service Workern. Solange das Handle offen ist, hält es eine exklusive Sperre auf die Datei. Andere Handles können die Datei in dieser Zeit nicht öffnen.

Rückgabewert

Typ
number
Beschreibung
Die Größe der Datei in Bytes als ganze Zahl (0 bei einer leeren Datei).

Beispiele

Dateigröße in einem Worker ermitteln

// worker.js – als dedizierter Worker gestartet
const root = await navigator.storage.getDirectory();
const fileHandle = await root.getFileHandle('notizen.txt', { create: true });
const access = await fileHandle.createSyncAccessHandle();

try {
  const encoder = new TextEncoder();
  access.truncate(0);
  access.write(encoder.encode('Hallo OPFS!'), { at: 0 });
  console.log('Größe:', access.getSize(), 'Bytes');
} finally {
  access.close();
}
Größe: 11 Bytes

Gesamte Datei in einen passend großen Puffer lesen

// worker.js
const readWholeFile = async (name) => {
  const root = await navigator.storage.getDirectory();
  const handle = await root.getFileHandle(name);
  const access = await handle.createSyncAccessHandle();
  try {
    const size = access.getSize();
    const buffer = new Uint8Array(size);
    const bytesRead = access.read(buffer, { at: 0 });
    return new TextDecoder().decode(buffer.subarray(0, bytesRead));
  } finally {
    access.close();
  }
};

console.log(await readWholeFile('notizen.txt'));
Hallo OPFS!

Log-Einträge am Dateiende anhängen

// worker.js
const root = await navigator.storage.getDirectory();
const logHandle = await root.getFileHandle('app.log', { create: true });
const log = await logHandle.createSyncAccessHandle();
const encoder = new TextEncoder();

const append = (line) => {
  const data = encoder.encode(`${new Date().toISOString()} ${line}\n`);
  // An der aktuellen Dateigröße schreiben = anhängen
  log.write(data, { at: log.getSize() });
};

append('Worker gestartet');
append('Daten geladen');
log.flush();
console.log('Log-Größe:', log.getSize());
log.close();
Log-Größe: 76

// Wichtig · Fallstricke

  • Frühere asynchrone Version: In Chromium 102–107 gab getSize() (wie auch truncate(), flush() und close()) ein Promise zurück. Seit Chrome 108 arbeitet die Methode synchron. Wer ältere Browser unterstützen muss, kann await access.getSize() schreiben. Das funktioniert in beiden Fällen.
  • Nach close() wirft getSize() eine DOMException vom Typ InvalidStateError.
  • Die Methode gibt es nur in dedizierten Web Workern. Im Hauptthread ist createSyncAccessHandle() nicht definiert. Dort gibt es alternativ (await fileHandle.getFile()).size.
  • Das Handle sperrt die Datei exklusiv. Deshalb das Handle immer in einem try/finally-Block schließen, sonst schlagen weitere createSyncAccessHandle()-Aufrufe mit NoModificationAllowedError fehl.
  • Nicht ohne Weiteres für den Zugriff aus mehreren Threads geeignet: Die Größe ist nur so lange gültig, wie niemand sonst in die Datei schreibt. Die exklusive Sperre sorgt aber in der Regel dafür.