ArrayBuffer.prototype.resizable — Eigenschaft · JavaScript-Referenz

Signatur

get ArrayBuffer.prototype.resizable

Beschreibung

Die Accessor-Eigenschaft resizable ist nur lesbar. Sie liefert true, wenn der ArrayBuffer mit der Option maxByteLength erzeugt wurde, z. B. new ArrayBuffer(8, { maxByteLength: 64 }). Wurde er ohne diese Option angelegt, hat er eine feste Länge und die Eigenschaft liefert false.

Das ist nützlich, wenn Code einen Puffer von außen übernimmt, etwa aus einer Bibliothek, einem Worker oder einer Stream-Verarbeitung, und prüfen muss, ob der Aufruf von ArrayBuffer.prototype.resize() erlaubt ist. Bei einem Puffer mit fester Länge wirft resize() einen TypeError.

Ob ein Puffer größenveränderbar ist, wird beim Anlegen festgelegt und ändert sich danach nicht mehr. Auch der Wert von maxByteLength bleibt fest. Bei Puffern mit fester Länge ist maxByteLength gleich byteLength. Typisierte Arrays ohne feste Länge (length-tracking), die auf einem größenveränderbaren Puffer liegen, passen ihre length automatisch an, wenn sich die Puffergröße ändert.

Rückgabewert

Typ

boolean

Beschreibung

true, wenn der Puffer mit maxByteLength erzeugt wurde und damit größenveränderbar ist, sonst false.

Beispiele

Fester und größenveränderbarer Puffer im Vergleich

const fest = new ArrayBuffer(8);
const flexibel = new ArrayBuffer(8, { maxByteLength: 64 });

console.log(fest.resizable);        // false
console.log(flexibel.resizable);    // true
console.log(fest.maxByteLength);    // 8
console.log(flexibel.maxByteLength); // 64

false true 8 64

Vor resize() sicher prüfen

const ensureCapacity = (buffer, benoetigt) => {
  if (buffer.byteLength >= benoetigt) return buffer;

  if (buffer.resizable && benoetigt <= buffer.maxByteLength) {
    buffer.resize(benoetigt); // Vergrößern ohne Kopieren
    return buffer;
  }

  // Rückfall: neuen Puffer anlegen und Daten kopieren
  const neu = new ArrayBuffer(benoetigt);
  new Uint8Array(neu).set(new Uint8Array(buffer));
  return neu;
};

const a = ensureCapacity(new ArrayBuffer(4, { maxByteLength: 32 }), 16);
const b = ensureCapacity(new ArrayBuffer(4), 16);
console.log(a.byteLength, a.resizable);
console.log(b.byteLength, b.resizable);

16 true 16 false

Typisiertes Array ohne feste Länge folgt der Puffergröße

const buffer = new ArrayBuffer(4, { maxByteLength: 16 });
const bytes = new Uint8Array(buffer); // keine feste Länge angegeben

console.log(buffer.resizable, bytes.length); // true 4
buffer.resize(12);
console.log(bytes.length); // 12
buffer.resize(2);
console.log(bytes.length); // 2

true 4 12 2

// Wichtig · Fallstricke

Die Eigenschaft ist nur lesbar. Eine Zuweisung wie buffer.resizable = true wird im Nicht-Strict-Modus stillschweigend ignoriert und wirft im Strict-Modus einen TypeError. Ob ein Puffer größenveränderbar ist, lässt sich nur beim Konstruktor-Aufruf festlegen.
Nach transfer() behält der neue Puffer die Größenveränderbarkeit des ursprünglichen Puffers. transferToFixedLength() erzeugt dagegen immer einen Puffer mit resizable === false.
Für SharedArrayBuffer gibt es stattdessen die Eigenschaft growable. Solche Puffer können nur wachsen, nicht schrumpfen.
Kompatibilität: Chrome/Edge 111+, Safari 16.4+, Firefox 128+, Node.js 20+. In älteren Umgebungen ist die Eigenschaft undefined. Deshalb bei der Funktionserkennung auf buffer.resizable === true prüfen, nicht auf !== false.
Wird ein Puffer verkleinert, können typisierte Arrays mit fester Länge außerhalb des gültigen Bereichs liegen. Dann haben sie length 0, und ein Zugriff liefert undefined.

Siehe auch

ArrayBuffer[Symbol.species] ArrayBuffer.prototype.detached ArrayBuffer.prototype.byteLength ArrayBuffer.prototype.maxByteLength SharedArrayBuffer.prototype.growable