TypedArray.prototype.buffer — Eigenschaft · JavaScript-Referenz

Signatur

get TypedArray.prototype.buffer

Beschreibung

Jedes typisierte Array (Uint8Array, Float32Array, Int16Array usw.) ist nur eine Sicht auf einen zusammenhängenden Speicherbereich. Diesen Speicher stellt ein ArrayBuffer oder SharedArrayBuffer bereit. Die Eigenschaft buffer gibt genau dieses zugrunde liegende Puffer-Objekt zurück. Sie ist nur lesbar (reiner Getter ohne Setter) und wird auf %TypedArray%.prototype definiert, also von allen typisierten Array-Klassen geerbt.

Nützlich ist buffer vor allem dann, wenn Sie mehrere Sichten auf denselben Speicher brauchen – etwa um Binärdaten als Bytes zu lesen und gleichzeitig als 32-Bit-Werte zu interpretieren, einen DataView für gemischte Datentypen und eine bestimmte Byte-Reihenfolge anzulegen oder Daten per postMessage an einen Worker zu übertragen (Transferable).

Wichtig: buffer liefert immer den gesamten Puffer, nicht nur den Ausschnitt, den das typisierte Array sieht. Wurde das Array mit byteOffset und length oder per subarray() erzeugt, müssen Sie zusätzlich byteOffset und byteLength beachten, um den richtigen Bereich zu erwischen.

Rückgabewert

Typ

ArrayBuffer | SharedArrayBuffer

Beschreibung

Das Puffer-Objekt, auf das das typisierte Array verweist. Es ist dasselbe Objekt, das bei der Konstruktion übergeben oder intern angelegt wurde (Identität bleibt erhalten).

Beispiele

Zugrunde liegenden Puffer abfragen

const bytes = new Uint8Array(8);
const buf = bytes.buffer;

console.log(buf instanceof ArrayBuffer);
console.log(buf.byteLength);

// Wird ein Puffer übergeben, ist es exakt dasselbe Objekt
const ab = new ArrayBuffer(16);
const floats = new Float32Array(ab);
console.log(floats.buffer === ab);

true 8 true

Zweite Sicht auf denselben Speicher (Byte-Reihenfolge prüfen)

const words = new Uint32Array([0x11223344]);
// Dieselben 4 Byte als einzelne Bytes betrachten
const bytes = new Uint8Array(words.buffer);

const littleEndian = bytes[0] === 0x44;
console.log(littleEndian ? 'Little Endian' : 'Big Endian');
console.log([...bytes].map((b) => b.toString(16)));

Little Endian [ '44', '33', '22', '11' ] // auf üblichen x86/ARM-Systemen

Fallstrick bei subarray(): Offset beachten

const all = new Uint8Array([10, 20, 30, 40, 50, 60]);
const part = all.subarray(2, 4); // Sicht auf [30, 40]

console.log(part.buffer === all.buffer);   // gleicher Puffer!
console.log(part.buffer.byteLength);       // gesamter Puffer

// Falsch: new Uint8Array(part.buffer) liefert alle 6 Bytes
// Richtig: Offset und Länge mitgeben
const copy = new Uint8Array(part.buffer, part.byteOffset, part.byteLength);
console.log([...copy]);

// Oder: echten, eigenständigen Puffer erzeugen
const exact = part.buffer.slice(part.byteOffset, part.byteOffset + part.byteLength);
console.log(exact.byteLength);

true 6 [ 30, 40 ] 2

Puffer an einen Worker übertragen

const worker = new Worker('worker.js');
const samples = new Float32Array(1024).map((_, i) => Math.sin(i / 10));

// Puffer wird übertragen statt kopiert (zero-copy)
worker.postMessage({ samples }, [samples.buffer]);

// Danach ist der Puffer im Hauptthread abgekoppelt (detached)
console.log(samples.length, samples.buffer.byteLength);

0 0

// Wichtig · Fallstricke

Gesamter Puffer statt Ausschnitt: Bei Arrays aus subarray() oder mit byteOffset enthält buffer auch Daten außerhalb der Sicht. Immer byteOffset/byteLength berücksichtigen – ein häufiger Fehler z. B. bei Node.js-Buffer-Objekten, die oft in einem gemeinsamen Pool-Puffer liegen.
Nur lesbar: Eine Zuweisung wie arr.buffer = x wird im nicht-strikten Modus stillschweigend ignoriert und wirft im Strict Mode einen TypeError.
Geteilter Speicher: Änderungen über eine Sicht sind sofort in allen anderen Sichten auf denselben Puffer sichtbar – es wird nichts kopiert.
Detached Buffer: Nach einem Transfer (postMessage, ArrayBuffer.prototype.transfer()) liefert buffer weiterhin das Objekt, dessen byteLength ist dann aber 0, und das typisierte Array hat die Länge 0.
SharedArrayBuffer: Steht im Browser nur in cross-origin-isolierten Kontexten zur Verfügung (Header Cross-Origin-Opener-Policy und Cross-Origin-Embedder-Policy).
Kompatibilität: In allen modernen Browsern und in Node.js verfügbar.

Siehe auch

TypedArray.prototype.byteOffset TypedArray.prototype.length TypedArray.prototype.byteLength TypedArray.BYTES_PER_ELEMENT TypedArray[Symbol.species]