Diese Seite dient als Einführung in die Arbeit mit binären Daten in JavaScript. Bun implementiert eine Reihe von Datentypen und Dienstprogrammen für die Arbeit mit binären Daten, von denen die meisten Web-Standard sind. Alle Bun-spezifischen APIs werden entsprechend gekennzeichnet.

Unten finden Sie ein schnelles "Spickzettel", das auch als Inhaltsverzeichnis dient. Klicken Sie auf ein Element in der linken Spalte, um zu diesem Abschnitt zu springen.

Klasse	Beschreibung
TypedArray	Eine Familie von Klassen, die eine Array-ähnliche Schnittstelle für die Interaktion mit binären Daten bereitstellen. Beinhaltet Uint8Array, Uint16Array, Int8Array und mehr.
Buffer	Eine Unterklasse von Uint8Array, die eine breite Palette von Komfortmethoden implementiert. Im Gegensatz zu den anderen Elementen in dieser Tabelle ist dies eine Node.js-API (die Bun implementiert). Sie kann nicht im Browser verwendet werden.
DataView	Eine Klasse, die eine get/set-API zum Schreiben einer bestimmten Anzahl von Bytes in einen ArrayBuffer bei einem bestimmten Byte-Offset bereitstellt. Wird häufig zum Lesen oder Schreiben binärer Protokolle verwendet.
Blob	Ein schreibgeschützter Blob binärer Daten, der normalerweise eine Datei darstellt. Hat einen MIME-type, eine size und Methoden zur Konvertierung in ArrayBuffer, ReadableStream und String.
File	Eine Unterklasse von Blob, die eine Datei darstellt. Hat einen name und einen lastModified-Zeitstempel. Es gibt experimentelle Unterstützung in Node.js v20.
BunFile	Nur Bun. Eine Unterklasse von Blob, die eine verzögert geladene Datei auf der Festplatte darstellt. Wird mit Bun.file(path) erstellt.

---

ArrayBuffer und Views

Bis 2009 gab es keine sprachnative Möglichkeit, binäre Daten in JavaScript zu speichern und zu manipulieren. ECMAScript v5 führte eine Reihe neuer Mechanismen dafür ein. Der grundlegendste Baustein ist ArrayBuffer, eine einfache Datenstruktur, die eine Sequenz von Bytes im Speicher darstellt.

// dieser Buffer kann 8 Bytes speichern
const buf = new ArrayBuffer(8);

Trotz des Namens ist es kein Array und unterstützt keine der Array-Methoden und Operatoren, die man erwarten könnte. Tatsächlich gibt es keine Möglichkeit, Werte direkt aus einem ArrayBuffer zu lesen oder zu schreiben. Man kann mit einem ArrayBuffer außer der Größenüberprüfung und dem Erstellen von "Slices" nicht viel anfangen.

const buf = new ArrayBuffer(8);
buf.byteLength; // => 8

const slice = buf.slice(0, 4); // gibt neuen ArrayBuffer zurück
slice.byteLength; // => 4

Um etwas Interessantes zu tun, benötigen wir ein Konstrukt, das als "View" bekannt ist. Ein View ist eine Klasse, die eine ArrayBuffer-Instanz umhüllt und es Ihnen ermöglicht, die zugrunde liegenden Daten zu lesen und zu manipulieren. Es gibt zwei Arten von Views: typed arrays und DataView.

DataView

Die DataView-Klasse ist eine Schnittstelle auf niedrigerer Ebene zum Lesen und Manipulieren der Daten in einem ArrayBuffer.

Unten erstellen wir eine neue DataView und setzen das erste Byte auf 3.

const buf = new ArrayBuffer(4);
// [0b00000000, 0b00000000, 0b00000000, 0b00000000]

const dv = new DataView(buf);
dv.setUint8(0, 3); // schreibe Wert 3 bei Byte-Offset 0
dv.getUint8(0); // => 3
// [0b00000011, 0b00000000, 0b00000000, 0b00000000]

Schreiben wir nun ein Uint16 bei Byte-Offset 1. Dies erfordert zwei Bytes. Wir verwenden den Wert 513, was 2 * 256 + 1 ist; in Bytes ist das 00000010 00000001.

dv.setUint16(1, 513);
// [0b00000011, 0b00000010, 0b00000001, 0b00000000]

console.log(dv.getUint16(1)); // => 513

Wir haben nun den ersten drei Bytes in unserem zugrunde liegenden ArrayBuffer einen Wert zugewiesen. Obwohl das zweite und dritte Byte mit setUint16() erstellt wurden, können wir jedes seiner Komponenten-Bytes weiterhin mit getUint8() lesen.

console.log(dv.getUint8(1)); // => 2
console.log(dv.getUint8(2)); // => 1

Der Versuch, einen Wert zu schreiben, der mehr Platz erfordert als im zugrunde liegenden ArrayBuffer verfügbar ist, verursacht einen Fehler. Unten versuchen wir, eine Float64 (die 8 Bytes erfordert) bei Byte-Offset 0 zu schreiben, aber es sind nur insgesamt vier Bytes im Buffer.

dv.setFloat64(0, 3.1415);
// ^ RangeError: Out of bounds access

Die folgenden Methoden sind auf DataView verfügbar:

Getter	Setter
getBigInt64()	setBigInt64()
getBigUint64()	setBigUint64()
getFloat32()	setFloat32()
getFloat64()	setFloat64()
getInt16()	setInt16()
getInt32()	setInt32()
getInt8()	setInt8()
getUint16()	setUint16()
getUint32()	setUint32()
getUint8()	setUint8()

TypedArray

Typed Arrays sind eine Familie von Klassen, die eine Array-ähnliche Schnittstelle für die Interaktion mit Daten in einem ArrayBuffer bereitstellen. Während eine DataView es Ihnen ermöglicht, Zahlen unterschiedlicher Größe bei einem bestimmten Offset zu schreiben, interpretiert ein TypedArray die zugrunde liegenden Bytes als ein Array von Zahlen, jeweils fester Größe.

NOTE

Es ist üblich, diese Familie von Klassen kollektiv als ihre gemeinsame Oberklasse `TypedArray` zu bezeichnen. Diese Klasse ist _intern_ in JavaScript; Sie können keine Instanzen davon direkt erstellen, und `TypedArray` ist nicht im globalen Scope definiert. Betrachten Sie es als eine `interface` oder eine abstrakte Klasse.

const buffer = new ArrayBuffer(3);
const arr = new Uint8Array(buffer);

// Inhalte werden mit Null initialisiert
console.log(arr); // Uint8Array(3) [0, 0, 0]

// Werte wie ein Array zuweisen
arr[0] = 0;
arr[1] = 10;
arr[2] = 255;
arr[3] = 255; // no-op, außerhalb der Grenzen

Während ein ArrayBuffer eine generische Sequenz von Bytes ist, interpretieren diese Typed-Array-Klassen die Bytes als ein Array von Zahlen einer bestimmten Byte-Größe. Die obere Zeile enthält die rohen Bytes, und die späteren Zeilen enthalten, wie diese Bytes interpretiert werden, wenn sie mit verschiedenen Typed-Array-Klassen betrachtet werden.

Die folgenden Klassen sind Typed Arrays, zusammen mit einer Beschreibung, wie sie die Bytes in einem ArrayBuffer interpretieren:

Hier ist die erste Tabelle als Markdown-Tabelle formatiert:

Klasse	Beschreibung
Uint8Array	Jedes einzelne (1) Byte wird als vorzeichenlose 8-Bit-Ganzzahl interpretiert. Bereich 0 bis 255.
Uint16Array	Jeweils zwei (2) Bytes werden als vorzeichenlose 16-Bit-Ganzzahl interpretiert. Bereich 0 bis 65535.
Uint32Array	Jeweils vier (4) Bytes werden als vorzeichenlose 32-Bit-Ganzzahl interpretiert. Bereich 0 bis 4294967295.
Int8Array	Jedes einzelne (1) Byte wird als vorzeichenbehaftete 8-Bit-Ganzzahl interpretiert. Bereich -128 bis 127.
Int16Array	Jeweils zwei (2) Bytes werden als vorzeichenbehaftete 16-Bit-Ganzzahl interpretiert. Bereich -32768 bis 32767.
Int32Array	Jeweils vier (4) Bytes werden als vorzeichenbehaftete 32-Bit-Ganzzahl interpretiert. Bereich -2147483648 bis 2147483647.
Float16Array	Jeweils zwei (2) Bytes werden als 16-Bit-Gleitkommazahl interpretiert. Bereich -6.104e5 bis 6.55e4.
Float32Array	Jeweils vier (4) Bytes werden als 32-Bit-Gleitkommazahl interpretiert. Bereich -3.4e38 bis 3.4e38.
Float64Array	Jeweils acht (8) Bytes werden als 64-Bit-Gleitkommazahl interpretiert. Bereich -1.7e308 bis 1.7e308.
BigInt64Array	Jeweils acht (8) Bytes werden als vorzeichenbehaftete BigInt interpretiert. Bereich -9223372036854775808 bis 9223372036854775807 (obwohl BigInt größere Zahlen darstellen kann).
BigUint64Array	Jeweils acht (8) Bytes werden als vorzeichenlose BigInt interpretiert. Bereich 0 bis 18446744073709551615 (obwohl BigInt größere Zahlen darstellen kann).
Uint8ClampedArray	Wie Uint8Array, aber "klemmt" automatisch auf den Bereich 0-255, wenn einem Element ein Wert zugewiesen wird.

Die Tabelle unten zeigt, wie die Bytes in einem ArrayBuffer interpretiert werden, wenn sie mit verschiedenen Typed-Array-Klassen betrachtet werden.

	Byte 0	Byte 1	Byte 2	Byte 3	Byte 4	Byte 5	Byte 6	Byte 7
ArrayBuffer	00000000	00000001	00000010	00000011	00000100	00000101	00000110	00000111
Uint8Array	0	1	2	3	4	5	6	7
Uint16Array	256 (1 * 256 + 0)		770 (3 * 256 + 2)		1284 (5 * 256 + 4)		1798 (7 * 256 + 6)
Uint32Array	50462976				117835012
BigUint64Array	506097522914230528n

So erstellen Sie ein Typed Array aus einem vordefinierten ArrayBuffer:

// Typed Array aus ArrayBuffer erstellen
const buf = new ArrayBuffer(10);
const arr = new Uint8Array(buf);

arr[0] = 30;
arr[1] = 60;

// alle Elemente werden mit Null initialisiert
console.log(arr); // => Uint8Array(10) [ 30, 60, 0, 0, 0, 0, 0, 0, 0, 0 ];

Wenn wir versuchen würden, ein Uint32Array aus demselben ArrayBuffer zu instanziieren, würden wir einen Fehler erhalten.

const buf = new ArrayBuffer(10);
const arr = new Uint32Array(buf);
//          ^  RangeError: ArrayBuffer length minus the byteOffset
//             is not a multiple of the element size

Ein Uint32-Wert erfordert vier Bytes (16 Bits). Da der ArrayBuffer 10 Bytes lang ist, gibt es keine Möglichkeit, seinen Inhalt sauber in 4-Byte-Blöcke zu teilen.

Um dies zu beheben, können wir ein Typed Array über einem bestimmten "Slice" eines ArrayBuffer erstellen. Das Uint16Array unten "betrachtet" nur die ersten 8 Bytes des zugrunde liegenden ArrayBuffer. Um dies zu erreichen, geben wir einen byteOffset von 0 und eine length von 2 an, was die Anzahl der Uint32-Zahlen angibt, die unser Array enthalten soll.

// Typed Array aus ArrayBuffer-Slice erstellen
const buf = new ArrayBuffer(10);
const arr = new Uint32Array(buf, 0, 2);

/*
  buf    _ _ _ _ _ _ _ _ _ _    10 bytes
  arr   [_______,_______]       2 4-Byte-Elemente
*/

arr.byteOffset; // 0
arr.length; // 2

Sie müssen keine ArrayBuffer-Instanz explizit erstellen; Sie können stattdessen direkt eine Länge im Typed-Array-Konstruktor angeben:

const arr2 = new Uint8Array(5);

// alle Elemente werden mit Null initialisiert
// => Uint8Array(5) [0, 0, 0, 0, 0]

Typed Arrays können auch direkt aus einem Array von Zahlen oder einem anderen Typed Array instanziiert werden:

// aus einem Array von Zahlen
const arr1 = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7]);
arr1[0]; // => 0;
arr1[7]; // => 7;

// aus einem anderen Typed Array
const arr2 = new Uint8Array(arr);

Groß gesagt bieten Typed Arrays die gleichen Methoden wie reguläre Arrays, mit wenigen Ausnahmen. Zum Beispiel sind push und pop auf Typed Arrays nicht verfügbar, da sie eine Größenänderung des zugrunde liegenden ArrayBuffer erfordern würden.

const arr = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7]);

// unterstützt gängige Array-Methoden
arr.filter(n => n > 128); // Uint8Array(1) [255]
arr.map(n => n * 2); // Uint8Array(8) [0, 2, 4, 6, 8, 10, 12, 14]
arr.reduce((acc, n) => acc + n, 0); // 28
arr.forEach(n => console.log(n)); // 0 1 2 3 4 5 6 7
arr.every(n => n < 10); // true
arr.find(n => n > 5); // 6
arr.includes(5); // true
arr.indexOf(5); // 5

Weitere Informationen zu den Eigenschaften und Methoden von Typed Arrays finden Sie in der MDN-Dokumentation.

Uint8Array

Es lohnt sich, Uint8Array besonders hervorzuheben, da es ein klassisches "Byte-Array" darstellt – eine Sequenz von 8-Bit-vorzeichenlosen Ganzzahlen zwischen 0 und 255. Dies ist das häufigste Typed Array, dem Sie in JavaScript begegnen werden.

In Bun, und eines Tages auch in anderen JavaScript-Engines, stehen Methoden zur Verfügung, um zwischen Byte-Arrays und serialisierten Darstellungen dieser Arrays als Base64- oder Hex-Strings zu konvertieren.

new Uint8Array([1, 2, 3, 4, 5]).toBase64(); // "AQIDBA=="
Uint8Array.fromBase64("AQIDBA=="); // Uint8Array(4) [1, 2, 3, 4, 5]

new Uint8Array([255, 254, 253, 252, 251]).toHex(); // "fffefdfcfb=="
Uint8Array.fromHex("fffefdfcfb"); // Uint8Array(5) [255, 254, 253, 252, 251]

Es ist der Rückgabewert von TextEncoder#encode und der Eingabetyp von TextDecoder#decode, zwei Dienstprogrammklassen, die zum Übersetzen von Strings und verschiedenen binären Kodierungen entwickelt wurden, insbesondere "utf-8".

const encoder = new TextEncoder();
const bytes = encoder.encode("hello world");
// => Uint8Array(11) [ 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100 ]

const decoder = new TextDecoder();
const text = decoder.decode(bytes);
// => hello world

Buffer

Bun implementiert Buffer, eine Node.js-API für die Arbeit mit binären Daten, die vor der Einführung von Typed Arrays in der JavaScript-Spezifikation existierte. Sie wurde seitdem als Unterklasse von Uint8Array neu implementiert. Sie bietet eine breite Palette von Methoden, einschließlich mehrerer Array-ähnlicher und DataView-ähnlicher Methoden.

const buf = Buffer.from("hello world");
// => Buffer(11) [ 104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100 ]

buf.length; // => 11
buf[0]; // => 104, ASCII für 'h'
buf.writeUInt8(72, 0); // => ASCII für 'H'

console.log(buf.toString());
// => Hello world

Vollständige Dokumentation finden Sie in der Node.js-Dokumentation.

Blob

Blob ist eine Web-API, die häufig zur Darstellung von Dateien verwendet wird. Blob wurde ursprünglich in Browsern implementiert (im Gegensatz zu ArrayBuffer, das Teil von JavaScript selbst ist), wird aber jetzt auch in Node und Bun unterstützt.

Es ist nicht üblich, Blob-Instanzen direkt zu erstellen. Häufiger erhalten Sie Instanzen von Blob aus einer externen Quelle (wie einem <input type="file">-Element im Browser) oder einer Bibliothek. Dennoch ist es möglich, ein Blob aus einem oder mehreren String- oder binären "Blob-Teilen" zu erstellen.

const blob = new Blob(["<html>Hello</html>"], {
  type: "text/html",
});

blob.type; // => text/html
blob.size; // => 19

Diese Teile können string, ArrayBuffer, TypedArray, DataView oder andere Blob-Instanzen sein. Die Blob-Teile werden in der Reihenfolge, in der sie bereitgestellt werden, zusammengeführt.

const blob = new Blob([
  "<html>",
  new Blob(["<body>"]),
  new Uint8Array([104, 101, 108, 108, 111]), // "hello" in binär
  "</body></html>",
]);

Der Inhalt eines Blob kann asynchron in verschiedenen Formaten gelesen werden.

await blob.text(); // => <html><body>hello</body></html>
await blob.bytes(); // => Uint8Array (kopiert Inhalte)
await blob.arrayBuffer(); // => ArrayBuffer (kopiert Inhalte)
await blob.stream(); // => ReadableStream

BunFile

BunFile ist eine Unterklasse von Blob, die verwendet wird, um eine verzögert geladene Datei auf der Festplatte darzustellen. Wie File fügt es eine name- und lastModified-Eigenschaft hinzu. Im Gegensatz zu File muss die Datei nicht in den Speicher geladen werden.

const file = Bun.file("index.txt");
// => BunFile

File

File ist eine Unterklasse von Blob, die eine name- und lastModified-Eigenschaft hinzufügt. Es wird häufig im Browser verwendet, um Dateien darzustellen, die über ein <input type="file">-Element hochgeladen wurden. Node.js und Bun implementieren File.

// im Browser!
// <input type="file" id="file" />

const files = document.getElementById("file").files;
// => File[]

const file = new File(["<html>Hello</html>"], "index.html", {
  type: "text/html",
});

Vollständige Dokumentationsinformationen finden Sie in der MDN-Dokumentation.

---

Streams

Streams sind eine wichtige Abstraktion für die Arbeit mit binären Daten, ohne sie alle auf einmal in den Speicher zu laden. Sie werden häufig zum Lesen und Schreiben von Dateien, zum Senden und Empfangen von Netzwerkanfragen und zur Verarbeitung großer Datenmengen verwendet.

Bun implementiert die Web-APIs ReadableStream und WritableStream.

NOTE

Bun implementiert auch das `node:stream`-Modul, einschließlich [`Readable`](https://nodejs.org/api/stream.html#stream_readable_streams), [`Writable`](https://nodejs.org/api/stream.html#stream_writable_streams) und [`Duplex`](https://nodejs.org/api/stream.html#stream_duplex_and_transform_streams). Vollständige Dokumentation finden Sie in der Node.js-Dokumentation.

So erstellen Sie einen einfachen ReadableStream:

const stream = new ReadableStream({
  start(controller) {
    controller.enqueue("hello");
    controller.enqueue("world");
    controller.close();
  },
});

Der Inhalt dieses Streams kann Chunk für Chunk mit der for await-Syntax gelesen werden.

for await (const chunk of stream) {
  console.log(chunk);
}

// => "hello"
// => "world"

Für eine umfassendere Diskussion von Streams in Bun siehe API > Streams.

---

Konvertierung

Die Konvertierung von einem binären Format in ein anderes ist eine häufige Aufgabe. Dieser Abschnitt dient als Referenz.

Von ArrayBuffer

Da ArrayBuffer die Daten speichert, die anderen binären Strukturen wie TypedArray zugrunde liegen, konvertieren die folgenden Snippets nicht von ArrayBuffer zu einem anderen Format. Stattdessen erstellen sie eine neue Instanz unter Verwendung der zugrunde liegend gespeicherten Daten.

Zu TypedArray

new Uint8Array(buf);

Zu DataView

new DataView(buf);

Zu Buffer

// Buffer über gesamten ArrayBuffer erstellen
Buffer.from(buf);

// Buffer über einem Slice des ArrayBuffer erstellen
Buffer.from(buf, 0, 10);

Zu string

Als UTF-8:

new TextDecoder().decode(buf);

Zu number[]

Array.from(new Uint8Array(buf));

Zu Blob

new Blob([buf], { type: "text/plain" });

Zu ReadableStream

Das folgende Snippet erstellt einen ReadableStream und reiht den gesamten ArrayBuffer als einzelnen Chunk ein.

new ReadableStream({
  start(controller) {
    controller.enqueue(buf);
    controller.close();
  },
});

Mit Chunking">

Um den ArrayBuffer in Chunks zu streamen, verwenden Sie einen Uint8Array-View und reihen Sie jeden Chunk ein.

const view = new Uint8Array(buf);
const chunkSize = 1024;

new ReadableStream({
  start(controller) {
    for (let i = 0; i < view.length; i += chunkSize) {
      controller.enqueue(view.slice(i, i + chunkSize));
    }
    controller.close();
  },
});

Von TypedArray

Zu ArrayBuffer

Dies ruft den zugrunde liegenden ArrayBuffer ab. Beachten Sie, dass ein TypedArray eine Ansicht eines Slices des zugrunde liegenden Buffers sein kann, sodass die Größen unterschiedlich sein können.

arr.buffer;

Zu DataView

Erstellt einen DataView über demselben Byte-Bereich wie das TypedArray.

new DataView(arr.buffer, arr.byteOffset, arr.byteLength);

Zu Buffer

Buffer.from(arr);

Zu string

Als UTF-8:

new TextDecoder().decode(arr);

Zu number[]

Array.from(arr);

Zu Blob

// nur wenn arr eine Ansicht seines gesamten zugrunde liegenden TypedArray ist
new Blob([arr.buffer], { type: "text/plain" });

Zu ReadableStream

new ReadableStream({
  start(controller) {
    controller.enqueue(arr);
    controller.close();
  },
});

Mit Chunking">

Um den ArrayBuffer in Chunks zu streamen, teilen Sie das TypedArray in Chunks und reihen Sie jeden einzeln ein.

new ReadableStream({
  start(controller) {
    for (let i = 0; i < arr.length; i += chunkSize) {
      controller.enqueue(arr.slice(i, i + chunkSize));
    }
    controller.close();
  },
});

Von DataView

Zu ArrayBuffer

view.buffer;

Zu TypedArray

Funktioniert nur, wenn die byteLength der DataView ein Vielfaches des BYTES_PER_ELEMENT der TypedArray-Unterklasse ist.

new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
new Uint16Array(view.buffer, view.byteOffset, view.byteLength / 2);
new Uint32Array(view.buffer, view.byteOffset, view.byteLength / 4);
// usw...

Zu Buffer

Buffer.from(view.buffer, view.byteOffset, view.byteLength);

Zu string

Als UTF-8:

new TextDecoder().decode(view);

Zu number[]

Array.from(view);

Zu Blob

new Blob([view.buffer], { type: "text/plain" });

Zu ReadableStream

new ReadableStream({
  start(controller) {
    controller.enqueue(view.buffer);
    controller.close();
  },
});

Mit Chunking">

Um den ArrayBuffer in Chunks zu streamen, teilen Sie die DataView in Chunks und reihen Sie jeden einzeln ein.

new ReadableStream({
  start(controller) {
    for (let i = 0; i < view.byteLength; i += chunkSize) {
      controller.enqueue(view.buffer.slice(i, i + chunkSize));
    }
    controller.close();
  },
});

Von Buffer

Zu ArrayBuffer

buf.buffer;

Zu TypedArray

new Uint8Array(buf);

Zu DataView

new DataView(buf.buffer, buf.byteOffset, buf.byteLength);

Zu string

Als UTF-8:

buf.toString();

Als Base64:

buf.toString("base64");

Als Hex:

buf.toString("hex");

Zu number[]

Array.from(buf);

Zu Blob

new Blob([buf], { type: "text/plain" });

Zu ReadableStream

new ReadableStream({
  start(controller) {
    controller.enqueue(buf);
    controller.close();
  },
});

Mit Chunking">

Um den ArrayBuffer in Chunks zu streamen, teilen Sie den Buffer in Chunks und reihen Sie jeden einzeln ein.

new ReadableStream({
  start(controller) {
    for (let i = 0; i < buf.length; i += chunkSize) {
      controller.enqueue(buf.slice(i, i + chunkSize));
    }
    controller.close();
  },
});

Von Blob

Zu ArrayBuffer

Die Blob-Klasse bietet eine Komfortmethode für diesen Zweck.

await blob.arrayBuffer();

Zu TypedArray

await blob.bytes();

Zu DataView

new DataView(await blob.arrayBuffer());

Zu Buffer

Buffer.from(await blob.arrayBuffer());

Zu string

Als UTF-8:

await blob.text();

Zu number[]

Array.from(await blob.bytes());

Zu ReadableStream

blob.stream();

Von ReadableStream

Es ist üblich, Response als praktische Zwischenrepräsentation zu verwenden, um die Konvertierung von ReadableStream in andere Formate zu erleichtern.

stream; // ReadableStream

const buffer = new Response(stream).arrayBuffer();

Dieser Ansatz ist jedoch umständlich und fügt Overhead hinzu, der die Gesamtleistung unnötig verlangsamt. Bun implementiert eine Reihe von optimierten Komfortfunktionen zur Konvertierung von ReadableStream in verschiedene binäre Formate.

Zu ArrayBuffer

// mit Response
new Response(stream).arrayBuffer();

// mit Bun-Funktion
Bun.readableStreamToArrayBuffer(stream);

Zu Uint8Array

// mit Response
new Response(stream).bytes();

// mit Bun-Funktion
Bun.readableStreamToBytes(stream);

Zu TypedArray

// mit Response
const buf = await new Response(stream).arrayBuffer();
new Int8Array(buf);

// mit Bun-Funktion
new Int8Array(Bun.readableStreamToArrayBuffer(stream));

Zu DataView

// mit Response
const buf = await new Response(stream).arrayBuffer();
new DataView(buf);

// mit Bun-Funktion
new DataView(Bun.readableStreamToArrayBuffer(stream));

Zu Buffer

// mit Response
const buf = await new Response(stream).arrayBuffer();
Buffer.from(buf);

// mit Bun-Funktion
Buffer.from(Bun.readableStreamToArrayBuffer(stream));

Zu string

Als UTF-8:

// mit Response
await new Response(stream).text();

// mit Bun-Funktion
await Bun.readableStreamToText(stream);

Zu number[]

// mit Response
const arr = await new Response(stream).bytes();
Array.from(arr);

// mit Bun-Funktion
Array.from(new Uint8Array(Bun.readableStreamToArrayBuffer(stream)));

Bun bietet ein Dienstprogramm zum Auflösen eines ReadableStream in ein Array seiner Chunks. Jeder Chunk kann ein String, ein Typed Array oder ein ArrayBuffer sein.

// mit Bun-Funktion
Bun.readableStreamToArray(stream);

Zu Blob

new Response(stream).blob();

Zu ReadableStream

Um einen ReadableStream in zwei Streams zu teilen, die unabhängig voneinander konsumiert werden können:

const [a, b] = stream.tee();