ByteLengthQueuingStrategy.size() — Methode · JavaScript-Referenz

Signatur

ByteLengthQueuingStrategy.prototype.size(chunk)

Beschreibung

Die Methode size() einer ByteLengthQueuingStrategy berechnet, wie viel ein einzelner Chunk zur Füllmenge der internen Warteschlange eines Streams beiträgt. Sie gibt dazu einfach chunk.byteLength zurück. Streams vergleichen die Summe dieser Werte mit dem highWaterMark der Strategie und leiten daraus desiredSize und damit den Gegendruck (Backpressure) ab.

Im Normalfall ruft man size() nicht selbst auf: Man übergibt die Strategie-Instanz als zweites Argument an new ReadableStream(), new WritableStream() oder als Strategie an einen TransformStream, und der Stream ruft size() bei jedem enqueue() bzw. write() auf. Ein direkter Aufruf ist trotzdem nützlich, etwa zum Testen oder um die Größe in einer eigenen Strategie wiederzuverwenden.

Die Strategie ist für binäre Daten gedacht – also Chunks, die eine byteLength-Eigenschaft besitzen: ArrayBuffer, typisierte Arrays wie Uint8Array und DataView. Für Streams, die Strings oder beliebige Objekte transportieren, eignet sich eher CountQueuingStrategy oder eine eigene size-Funktion.

Parameter

Name	Typ	Default	Beschreibung
$chunk Pflicht	ArrayBuffer \| ArrayBufferView \| { byteLength: number }		Der Datenblock, dessen Größe ermittelt werden soll. Es wird ausschließlich die Eigenschaft `byteLength` ausgelesen.

Rückgabewert

Typ

number

Beschreibung

Der Wert von chunk.byteLength, also die Größe des Chunks in Bytes. Fehlt die Eigenschaft, ist das Ergebnis undefined.

Beispiele

Größe verschiedener Binärdaten direkt ermitteln

const strategy = new ByteLengthQueuingStrategy({ highWaterMark: 1024 });

console.log(strategy.size(new Uint8Array(16)));          // typisiertes Array
console.log(strategy.size(new ArrayBuffer(32)));         // roher Puffer
console.log(strategy.size(new Float64Array(4)));         // 4 × 8 Bytes
console.log(strategy.size(new DataView(new ArrayBuffer(8))));
console.log(strategy.highWaterMark);

16 32 32 8 1024

Backpressure in einem ReadableStream beobachten

const stream = new ReadableStream(
  {
    start(controller) {
      controller.enqueue(new Uint8Array(10));
      console.log('Nach 10 Bytes:', controller.desiredSize);

      controller.enqueue(new Uint8Array(10));
      console.log('Nach 20 Bytes:', controller.desiredSize);
    },
  },
  // size() wird bei jedem enqueue() automatisch aufgerufen
  new ByteLengthQueuingStrategy({ highWaterMark: 16 })
);

Nach 10 Bytes: 6 Nach 20 Bytes: -4

WritableStream mit Byte-basiertem Puffer

const sink = new WritableStream(
  {
    async write(chunk) {
      // langsame Senke simulieren
      await new Promise((r) => setTimeout(r, 50));
      console.log(`${chunk.byteLength} Bytes geschrieben`);
    },
  },
  new ByteLengthQueuingStrategy({ highWaterMark: 64 * 1024 })
);

const writer = sink.getWriter();
for (let i = 0; i < 3; i++) {
  await writer.ready; // wartet, sobald 64 KiB gepuffert sind
  writer.write(new Uint8Array(32 * 1024));
}
await writer.close();

32768 Bytes geschrieben 32768 Bytes geschrieben 32768 Bytes geschrieben

Eigene Strategie für Text auf Byte-Basis

const encoder = new TextEncoder();
const byteStrategy = new ByteLengthQueuingStrategy({ highWaterMark: 1 });

// Strings haben kein byteLength – also erst kodieren
const textStrategy = {
  highWaterMark: 256,
  size: (text) => byteStrategy.size(encoder.encode(text)),
};

console.log(textStrategy.size('Hallo'));
console.log(textStrategy.size('Grüße')); // ü und ß belegen je 2 Bytes

5 7

// Wichtig · Fallstricke

Nur für Binärdaten: Wird ein Chunk ohne byteLength (z. B. ein String) eingereiht, liefert size() undefined. Der Stream wertet das als ungültige Größe: enqueue() bzw. write() wirft einen RangeError, und der Stream geht in den Fehlerzustand über.
Nicht an die Instanz gebunden: size nutzt this nicht. Man kann die Funktion daher herauslösen (const { size } = strategy) oder als Callback übergeben. Alle Instanzen innerhalb eines Realms teilen sich dieselbe Funktion.
Abgetrennte Puffer: Ein übertragener (detached) ArrayBuffer hat eine byteLength von 0 und zählt deshalb nicht mehr zur Füllmenge.
Byte-Streams: Für ReadableStreams mit type: 'bytes' darf keine size-Funktion angegeben werden; dort wird ausschließlich highWaterMark verwendet.
Kompatibilität: In allen aktuellen Browsern verfügbar (Firefox erst seit Version 102). In Node.js ab 16.5 über require('stream/web'), ab Version 18 global.

Siehe auch

CountQueuingStrategy.size() new ByteLengthQueuingStrategy() new CountQueuingStrategy() SVGLengthList.initialize() BluetoothUUID.getService()