Node.js v26.0.0 Dokumentation

Buffer#

Buffer-Objekte werden verwendet, um eine Sequenz fester Länge von Bytes darzustellen. Viele Node.js-APIs unterstützen Buffer.

Die Buffer-Klasse ist eine Unterklasse der JavaScript <Uint8Array>-Klasse und erweitert sie um Methoden für zusätzliche Anwendungsfälle. Node.js-APIs akzeptieren überall dort, wo Buffer unterstützt werden, auch einfache <Uint8Array>.

Obwohl die Buffer-Klasse im globalen Bereich verfügbar ist, wird dennoch empfohlen, explizit über ein import- oder require-Statement darauf zu verweisen.

import { Buffer } from 'node:buffer';

// Creates a zero-filled Buffer of length 10.
const buf1 = Buffer.alloc(10);

// Creates a Buffer of length 10,
// filled with bytes which all have the value `1`.
const buf2 = Buffer.alloc(10, 1);

// Creates an uninitialized buffer of length 10.
// This is faster than calling Buffer.alloc() but the returned
// Buffer instance might contain old data that needs to be
// overwritten using fill(), write(), or other functions that fill the Buffer's
// contents.
const buf3 = Buffer.allocUnsafe(10);

// Creates a Buffer containing the bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3]);

// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries
// are all truncated using `(value & 255)` to fit into the range 0–255.
const buf5 = Buffer.from([257, 257.5, -255, '1']);

// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)
// [116, 195, 169, 115, 116] (in decimal notation)
const buf6 = Buffer.from('tést');

// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1');
const { Buffer } = require('node:buffer');

// Creates a zero-filled Buffer of length 10.
const buf1 = Buffer.alloc(10);

// Creates a Buffer of length 10,
// filled with bytes which all have the value `1`.
const buf2 = Buffer.alloc(10, 1);

// Creates an uninitialized buffer of length 10.
// This is faster than calling Buffer.alloc() but the returned
// Buffer instance might contain old data that needs to be
// overwritten using fill(), write(), or other functions that fill the Buffer's
// contents.
const buf3 = Buffer.allocUnsafe(10);

// Creates a Buffer containing the bytes [1, 2, 3].
const buf4 = Buffer.from([1, 2, 3]);

// Creates a Buffer containing the bytes [1, 1, 1, 1] – the entries
// are all truncated using `(value & 255)` to fit into the range 0–255.
const buf5 = Buffer.from([257, 257.5, -255, '1']);

// Creates a Buffer containing the UTF-8-encoded bytes for the string 'tést':
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadecimal notation)
// [116, 195, 169, 115, 116] (in decimal notation)
const buf6 = Buffer.from('tést');

// Creates a Buffer containing the Latin-1 bytes [0x74, 0xe9, 0x73, 0x74].
const buf7 = Buffer.from('tést', 'latin1');
copy

Buffer und Zeichenkodierungen#

Bei der Konvertierung zwischen Buffer und Strings kann eine Zeichenkodierung angegeben werden. Wenn keine Zeichenkodierung angegeben ist, wird UTF-8 als Standard verwendet.

import { Buffer } from 'node:buffer';

const buf = Buffer.from('hello world', 'utf8');

console.log(buf.toString('hex'));
// Prints: 68656c6c6f20776f726c64
console.log(buf.toString('base64'));
// Prints: aGVsbG8gd29ybGQ=

console.log(Buffer.from('fhqwhgads', 'utf8'));
// Prints: <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'));
// Prints: <Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>
const { Buffer } = require('node:buffer');

const buf = Buffer.from('hello world', 'utf8');

console.log(buf.toString('hex'));
// Prints: 68656c6c6f20776f726c64
console.log(buf.toString('base64'));
// Prints: aGVsbG8gd29ybGQ=

console.log(Buffer.from('fhqwhgads', 'utf8'));
// Prints: <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'));
// Prints: <Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>
copy

Node.js-Buffer akzeptieren alle Schreibweisen von Kodierungs-Strings, die sie erhalten. Beispielsweise kann UTF-8 als 'utf8', 'UTF8' oder 'uTf8' angegeben werden.

Die derzeit von Node.js unterstützten Zeichenkodierungen sind die folgenden

• 'utf8' (Alias: 'utf-8'): Multi-Byte-kodierte Unicode-Zeichen. Viele Webseiten und andere Dokumentformate verwenden UTF-8. Dies ist die Standard-Zeichenkodierung. Beim Dekodieren eines Buffer in einen String, der nicht ausschließlich gültige UTF-8-Daten enthält, wird das Unicode-Ersatzzeichen U+FFFD verwendet, um diese Fehler darzustellen.

• 'utf16le' (Alias: 'utf-16le'): Multi-Byte-kodierte Unicode-Zeichen. Im Gegensatz zu 'utf8' wird jedes Zeichen im String mit 2 oder 4 Bytes kodiert. Node.js unterstützt nur die Little-Endian-Variante von UTF-16.

• 'latin1': Latin-1 steht für ISO-8859-1. Diese Zeichenkodierung unterstützt nur Unicode-Zeichen von U+0000 bis U+00FF. Jedes Zeichen wird mit einem einzigen Byte kodiert. Zeichen, die nicht in diesen Bereich passen, werden abgeschnitten und auf Zeichen in diesem Bereich abgebildet.

Die Umwandlung eines Buffer in einen String unter Verwendung einer der oben genannten Kodierungen wird als Dekodieren bezeichnet, und die Umwandlung eines Strings in einen Buffer als Kodieren.

Node.js unterstützt auch die folgenden Binär-zu-Text-Kodierungen. Bei Binär-zu-Text-Kodierungen ist die Namenskonvention umgekehrt: Das Konvertieren eines Buffer in einen String wird normalerweise als Kodieren bezeichnet, und das Konvertieren eines Strings in einen Buffer als Dekodieren.

• 'base64': Base64-Kodierung. Beim Erstellen eines Buffer aus einem String akzeptiert diese Kodierung auch das "URL and Filename Safe Alphabet", wie in RFC 4648, Abschnitt 5 spezifiziert. Leerzeichen wie Leerzeichen, Tabs und Zeilenumbrüche innerhalb des base64-kodierten Strings werden ignoriert.

• 'base64url': base64url-Kodierung wie in RFC 4648, Abschnitt 5 spezifiziert. Beim Erstellen eines Buffer aus einem String akzeptiert diese Kodierung auch reguläre base64-kodierte Strings. Beim Kodieren eines Buffer in einen String lässt diese Kodierung das Padding weg.

• 'hex': Kodiert jedes Byte als zwei hexadezimale Zeichen. Beim Dekodieren von Strings, die nicht ausschließlich aus einer geraden Anzahl von hexadezimalen Zeichen bestehen, kann eine Datenkürzung auftreten. Siehe unten für ein Beispiel.

Die folgenden älteren Zeichenkodierungen werden ebenfalls unterstützt

• 'ascii': Nur für 7-Bit ASCII-Daten. Beim Kodieren eines Strings in einen Buffer ist dies äquivalent zur Verwendung von 'latin1'. Beim Dekodieren eines Buffer in einen String setzt die Verwendung dieser Kodierung zusätzlich das höchste Bit jedes Bytes zurück, bevor es als 'latin1' dekodiert wird. Im Allgemeinen gibt es keinen Grund, diese Kodierung zu verwenden, da 'utf8' (oder, wenn bekannt ist, dass die Daten immer nur ASCII enthalten, 'latin1') eine bessere Wahl beim Kodieren oder Dekodieren von reinem ASCII-Text ist. Sie wird nur aus Gründen der Abwärtskompatibilität bereitgestellt.

• 'binary': Alias für 'latin1'. Der Name dieser Kodierung kann sehr irreführend sein, da alle hier aufgeführten Kodierungen zwischen Strings und Binärdaten konvertieren. Für die Konvertierung zwischen Strings und Buffer ist normalerweise 'utf8' die richtige Wahl.

• 'ucs2', 'ucs-2': Aliase für 'utf16le'. UCS-2 bezog sich früher auf eine Variante von UTF-16, die keine Zeichen mit Codepunkten größer als U+FFFF unterstützte. In Node.js werden diese Codepunkte immer unterstützt.

import { Buffer } from 'node:buffer';

Buffer.from('1ag123', 'hex');
// Prints <Buffer 1a>, data truncated when first non-hexadecimal value
// ('g') encountered.

Buffer.from('1a7', 'hex');
// Prints <Buffer 1a>, data truncated when data ends in single digit ('7').

Buffer.from('1634', 'hex');
// Prints <Buffer 16 34>, all data represented.
const { Buffer } = require('node:buffer');

Buffer.from('1ag123', 'hex');
// Prints <Buffer 1a>, data truncated when first non-hexadecimal value
// ('g') encountered.

Buffer.from('1a7', 'hex');
// Prints <Buffer 1a>, data truncated when data ends in single digit ('7').

Buffer.from('1634', 'hex');
// Prints <Buffer 16 34>, all data represented.
copy

Moderne Webbrowser folgen dem WHATWG Encoding Standard, der sowohl 'latin1' als auch 'ISO-8859-1' auf 'win-1252' abbildet. Das bedeutet, dass bei Dingen wie http.get(), wenn der zurückgegebene Zeichensatz einer der in der WHATWG-Spezifikation aufgeführten ist, es möglich ist, dass der Server tatsächlich 'win-1252'-kodierte Daten zurückgegeben hat, und die Verwendung der 'latin1'-Kodierung die Zeichen möglicherweise falsch dekodiert.

Buffer und TypedArrays#

Buffer-Instanzen sind auch JavaScript <Uint8Array>- und <TypedArray>-Instanzen. Alle <TypedArray>-Methoden und -Eigenschaften sind auf Buffer verfügbar. Es gibt jedoch subtile Inkompatibilitäten zwischen der Buffer-API und der <TypedArray>-API.

Insbesondere

• Während TypedArray.prototype.slice() eine Kopie eines Teils des TypedArray erstellt, erstellt Buffer.prototype.slice() eine Ansicht über den existierenden Buffer, ohne zu kopieren. Dieses Verhalten kann überraschend sein und existiert nur aus Gründen der Abwärtskompatibilität. TypedArray.prototype.subarray() kann verwendet werden, um das Verhalten von Buffer.prototype.slice() sowohl auf Buffer als auch auf anderen TypedArrays zu erreichen und sollte bevorzugt werden.
• buf.toString() ist inkompatibel mit seinem TypedArray-Äquivalent.
• Eine Reihe von Methoden, z. B. buf.indexOf(), unterstützen zusätzliche Argumente.

Es gibt zwei Möglichkeiten, neue <TypedArray>-Instanzen aus einem Buffer zu erstellen

• Das Übergeben eines Buffer an einen <TypedArray>-Konstruktor kopiert den Inhalt des Buffer, interpretiert als ein Array von Ganzzahlen und nicht als Byte-Sequenz des Zieltyps.

import { Buffer } from 'node:buffer';

const buf = Buffer.from([1, 2, 3, 4]);
const uint32array = new Uint32Array(buf);

console.log(uint32array);

// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]
const { Buffer } = require('node:buffer');

const buf = Buffer.from([1, 2, 3, 4]);
const uint32array = new Uint32Array(buf);

console.log(uint32array);

// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]
copy

• Das Übergeben des zugrunde liegenden <ArrayBuffer> des Buffer erstellt ein <TypedArray>, das seinen Speicher mit dem Buffer teilt.

import { Buffer } from 'node:buffer';

const buf = Buffer.from('hello', 'utf16le');
const uint16array = new Uint16Array(
  buf.buffer,
  buf.byteOffset,
  buf.length / Uint16Array.BYTES_PER_ELEMENT);

console.log(uint16array);

// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]
const { Buffer } = require('node:buffer');

const buf = Buffer.from('hello', 'utf16le');
const uint16array = new Uint16Array(
  buf.buffer,
  buf.byteOffset,
  buf.length / Uint16Array.BYTES_PER_ELEMENT);

console.log(uint16array);

// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]
copy

Es ist möglich, einen neuen Buffer zu erstellen, der den gleichen zugewiesenen Speicher wie eine <TypedArray>-Instanz teilt, indem man die .buffer-Eigenschaft des TypedArray-Objekts auf die gleiche Weise verwendet. Buffer.from() verhält sich in diesem Kontext wie new Uint8Array().

import { Buffer } from 'node:buffer';

const arr = new Uint16Array(2);

arr[0] = 5000;
arr[1] = 4000;

// Copies the contents of `arr`.
const buf1 = Buffer.from(arr);

// Shares memory with `arr`.
const buf2 = Buffer.from(arr.buffer);

console.log(buf1);
// Prints: <Buffer 88 a0>
console.log(buf2);
// Prints: <Buffer 88 13 a0 0f>

arr[1] = 6000;

console.log(buf1);
// Prints: <Buffer 88 a0>
console.log(buf2);
// Prints: <Buffer 88 13 70 17>
const { Buffer } = require('node:buffer');

const arr = new Uint16Array(2);

arr[0] = 5000;
arr[1] = 4000;

// Copies the contents of `arr`.
const buf1 = Buffer.from(arr);

// Shares memory with `arr`.
const buf2 = Buffer.from(arr.buffer);

console.log(buf1);
// Prints: <Buffer 88 a0>
console.log(buf2);
// Prints: <Buffer 88 13 a0 0f>

arr[1] = 6000;

console.log(buf1);
// Prints: <Buffer 88 a0>
console.log(buf2);
// Prints: <Buffer 88 13 70 17>
copy

Beim Erstellen eines Buffer unter Verwendung des .buffer eines <TypedArray> ist es möglich, nur einen Teil des zugrunde liegenden <ArrayBuffer> zu verwenden, indem man byteOffset- und length-Parameter übergibt.

import { Buffer } from 'node:buffer';

const arr = new Uint16Array(20);
const buf = Buffer.from(arr.buffer, 0, 16);

console.log(buf.length);
// Prints: 16
const { Buffer } = require('node:buffer');

const arr = new Uint16Array(20);
const buf = Buffer.from(arr.buffer, 0, 16);

console.log(buf.length);
// Prints: 16
copy

Buffer.from() und TypedArray.from() haben unterschiedliche Signaturen und Implementierungen. Insbesondere akzeptieren die <TypedArray>-Varianten ein zweites Argument, das eine Mapping-Funktion ist, die auf jedes Element des Typed Array aufgerufen wird

• TypedArray.from(source[, mapFn[, thisArg]])

Die Buffer.from()-Methode unterstützt jedoch nicht die Verwendung einer Mapping-Funktion

• Buffer.from(array)
• Buffer.from(buffer)
• Buffer.from(arrayBuffer[, byteOffset[, length]])
• Buffer.from(string[, encoding])

Buffer-Methoden sind mit Uint8Array-Instanzen aufrufbar#

Alle Methoden auf dem Buffer-Prototyp sind mit einer Uint8Array-Instanz aufrufbar.

const { toString, write } = Buffer.prototype;

const uint8array = new Uint8Array(5);

write.call(uint8array, 'hello', 0, 5, 'utf8'); // 5
// <Uint8Array 68 65 6c 6c 6f>

toString.call(uint8array, 'utf8'); // 'hello'
copy

Buffer und Iteration#

Buffer-Instanzen können mit der for..of-Syntax iteriert werden

import { Buffer } from 'node:buffer';

const buf = Buffer.from([1, 2, 3]);

for (const b of buf) {
  console.log(b);
}
// Prints:
//   1
//   2
//   3
const { Buffer } = require('node:buffer');

const buf = Buffer.from([1, 2, 3]);

for (const b of buf) {
  console.log(b);
}
// Prints:
//   1
//   2
//   3
copy

Zusätzlich können die Methoden buf.values(), buf.keys() und buf.entries() verwendet werden, um Iteratoren zu erstellen.

Klasse: Blob#

Ein <Blob> kapselt unveränderliche, rohe Daten, die sicher über mehrere Worker-Threads hinweg geteilt werden können.

new buffer.Blob([sources[, options]])#

• sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> Ein Array von String-, <ArrayBuffer>, <TypedArray>, <DataView>- oder <Blob>-Objekten oder eine Mischung aus solchen Objekten, die innerhalb des Blob gespeichert werden.
• options <Object>
  • endings <string> Entweder 'transparent' oder 'native'. Wenn auf 'native' gesetzt, werden Zeilenenden in String-Quellteilen in das plattformnative Zeilenende konvertiert, wie durch require('node:os').EOL angegeben.
  • type <string> Der Blob-Inhaltstyp. Die Absicht ist, dass type den MIME-Medientyp der Daten vermittelt; es wird jedoch keine Validierung des Typformats durchgeführt.

Erstellt ein neues Blob-Objekt, das eine Verkettung der angegebenen Quellen enthält.

<ArrayBuffer>, <TypedArray>, <DataView>- und <Buffer>-Quellen werden in den 'Blob' kopiert und können daher nach der Erstellung des 'Blob' sicher modifiziert werden.

String-Quellen werden als UTF-8-Byte-Sequenzen kodiert und in den Blob kopiert. Nicht übereinstimmende Surrogate-Paare innerhalb jedes String-Teils werden durch Unicode U+FFFD-Ersatzzeichen ersetzt.

blob.arrayBuffer()#

• Rückgabewert: <Promise>

Gibt ein Promise zurück, das mit einem <ArrayBuffer> erfüllt wird, der eine Kopie der Blob-Daten enthält.

blob.bytes()#

Die blob.bytes()-Methode gibt das Byte des Blob-Objekts als Promise<Uint8Array> zurück.

const blob = new Blob(['hello']);
blob.bytes().then((bytes) => {
  console.log(bytes); // Outputs: Uint8Array(5) [ 104, 101, 108, 108, 111 ]
});
copy

blob.size#

Die Gesamtgröße des Blob in Bytes.

blob.slice([start[, end[, type]]])#

• start <number> Der Startindex.
• end <number> Der Endindex.
• type <string> Der Inhaltstyp für das neue Blob

Erstellt und gibt ein neues Blob zurück, das eine Teilmenge der Daten dieses Blob-Objekts enthält. Das ursprüngliche Blob wird nicht verändert.

blob.stream()#

• Gibt zurück: <ReadableStream>

Gibt einen neuen ReadableStream zurück, der es ermöglicht, den Inhalt des Blob zu lesen.

blob.text()#

• Rückgabewert: <Promise>

Gibt ein Promise zurück, das mit dem Inhalt des Blob erfüllt wird, dekodiert als UTF-8-String.

blob.type#

• Typ: <string>

Der Inhaltstyp des Blob.

Blob-Objekte und MessageChannel#

Sobald ein <Blob>-Objekt erstellt wurde, kann es via MessagePort an mehrere Ziele gesendet werden, ohne die Daten zu übertragen oder sofort zu kopieren. Die vom Blob enthaltenen Daten werden nur kopiert, wenn die arrayBuffer()- oder text()-Methoden aufgerufen werden.

import { Blob } from 'node:buffer';
import { setTimeout as delay } from 'node:timers/promises';

const blob = new Blob(['hello there']);

const mc1 = new MessageChannel();
const mc2 = new MessageChannel();

mc1.port1.onmessage = async ({ data }) => {
  console.log(await data.arrayBuffer());
  mc1.port1.close();
};

mc2.port1.onmessage = async ({ data }) => {
  await delay(1000);
  console.log(await data.arrayBuffer());
  mc2.port1.close();
};

mc1.port2.postMessage(blob);
mc2.port2.postMessage(blob);

// The Blob is still usable after posting.
blob.text().then(console.log);
const { Blob } = require('node:buffer');
const { setTimeout: delay } = require('node:timers/promises');

const blob = new Blob(['hello there']);

const mc1 = new MessageChannel();
const mc2 = new MessageChannel();

mc1.port1.onmessage = async ({ data }) => {
  console.log(await data.arrayBuffer());
  mc1.port1.close();
};

mc2.port1.onmessage = async ({ data }) => {
  await delay(1000);
  console.log(await data.arrayBuffer());
  mc2.port1.close();
};

mc1.port2.postMessage(blob);
mc2.port2.postMessage(blob);

// The Blob is still usable after posting.
blob.text().then(console.log);
copy

Klasse: Buffer#

Die Buffer-Klasse ist ein globaler Typ für den direkten Umgang mit Binärdaten. Sie kann auf vielfältige Weise konstruiert werden.

Statische Methode: Buffer.alloc(size[, fill[, encoding]])#

• size <integer> Die gewünschte Länge des neuen Buffer.
• fill <string> | <Buffer> | <Uint8Array> | <integer> Ein Wert, mit dem der neue Buffer vorbefüllt werden soll. Standard: 0.
• encoding <string> Wenn fill ein String ist, ist dies dessen Kodierung. Standard: 'utf8'.
• Rückgabewert: <Buffer>

Weist einen neuen Buffer der Größe size Bytes zu. Wenn fill undefined ist, wird der Buffer mit Nullen gefüllt.

import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(5);

console.log(buf);
// Prints: <Buffer 00 00 00 00 00>
const { Buffer } = require('node:buffer');

const buf = Buffer.alloc(5);

console.log(buf);
// Prints: <Buffer 00 00 00 00 00>
copy

Wenn size größer als buffer.constants.MAX_LENGTH oder kleiner als 0 ist, wird ERR_OUT_OF_RANGE geworfen.

Wenn fill angegeben ist, wird der zugewiesene Buffer durch Aufruf von buf.fill(fill) initialisiert.

import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(5, 'a');

console.log(buf);
// Prints: <Buffer 61 61 61 61 61>
const { Buffer } = require('node:buffer');

const buf = Buffer.alloc(5, 'a');

console.log(buf);
// Prints: <Buffer 61 61 61 61 61>
copy

Wenn sowohl fill als auch encoding angegeben sind, wird der zugewiesene Buffer durch Aufruf von buf.fill(fill, encoding) initialisiert.

import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');

console.log(buf);
// Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>
const { Buffer } = require('node:buffer');

const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');

console.log(buf);
// Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>
copy

Der Aufruf von Buffer.alloc() kann messbar langsamer sein als die Alternative Buffer.allocUnsafe(), stellt aber sicher, dass der Inhalt der neu erstellten Buffer-Instanz niemals sensible Daten aus früheren Zuweisungen enthält, einschließlich Daten, die möglicherweise nicht für Buffer zugewiesen wurden.

Ein TypeError wird geworfen, wenn size keine Zahl ist.

Statische Methode: Buffer.allocUnsafe(size)#

• size <integer> Die gewünschte Länge des neuen Buffer.
• Rückgabewert: <Buffer>

Weist einen neuen Buffer der Größe size Bytes zu. Wenn size größer als buffer.constants.MAX_LENGTH oder kleiner als 0 ist, wird ERR_OUT_OF_RANGE geworfen.

Der zugrunde liegende Speicher für Buffer-Instanzen, die auf diese Weise erstellt werden, ist nicht initialisiert. Der Inhalt des neu erstellten Buffer ist unbekannt und kann sensible Daten enthalten. Verwenden Sie stattdessen Buffer.alloc(), um Buffer-Instanzen mit Nullen zu initialisieren.

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(10);

console.log(buf);
// Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0);

console.log(buf);
// Prints: <Buffer 00 00 00 00 00 00 00 00 00 00>
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(10);

console.log(buf);
// Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0);

console.log(buf);
// Prints: <Buffer 00 00 00 00 00 00 00 00 00 00>
copy

Ein TypeError wird geworfen, wenn size keine Zahl ist.

Das Buffer-Modul reserviert vorab eine interne Buffer-Instanz der Größe Buffer.poolSize, die als Pool für die schnelle Zuweisung neuer Buffer-Instanzen verwendet wird, die unter Verwendung von Buffer.allocUnsafe(), Buffer.from(array), Buffer.from(string) und Buffer.concat() erstellt werden, nur wenn size kleiner als Buffer.poolSize >>> 1 (Abrundung von Buffer.poolSize geteilt durch zwei) ist.

Die Verwendung dieses vorab reservierten internen Speicherpools ist ein Hauptunterschied zwischen dem Aufruf von Buffer.alloc(size, fill) und Buffer.allocUnsafe(size).fill(fill). Insbesondere wird Buffer.alloc(size, fill) niemals den internen Buffer-Pool verwenden, während Buffer.allocUnsafe(size).fill(fill) den internen Buffer-Pool verwenden wird, wenn size kleiner oder gleich der Hälfte von Buffer.poolSize ist. Der Unterschied ist subtil, kann aber wichtig sein, wenn eine Anwendung die zusätzliche Leistung benötigt, die Buffer.allocUnsafe() bietet.

Statische Methode: Buffer.allocUnsafeSlow(size)#

• size <integer> Die gewünschte Länge des neuen Buffer.
• Rückgabewert: <Buffer>

Weist einen neuen Buffer der Größe size Bytes zu. Wenn size größer als buffer.constants.MAX_LENGTH oder kleiner als 0 ist, wird ERR_OUT_OF_RANGE geworfen. Ein Buffer der Länge Null wird erstellt, wenn size 0 ist.

Der zugrunde liegende Speicher für Buffer-Instanzen, die auf diese Weise erstellt werden, ist nicht initialisiert. Der Inhalt des neu erstellten Buffer ist unbekannt und kann sensible Daten enthalten. Verwenden Sie buf.fill(0), um solche Buffer-Instanzen mit Nullen zu initialisieren.

Bei der Verwendung von Buffer.allocUnsafe() zur Zuweisung neuer Buffer-Instanzen werden Zuweisungen kleiner als Buffer.poolSize >>> 1 (4KiB, wenn die Standard-poolSize verwendet wird) aus einem einzelnen, vorab reservierten Buffer herausgeschnitten. Dies ermöglicht es Anwendungen, den Garbage-Collection-Overhead der Erstellung vieler einzeln zugewiesener Buffer-Instanzen zu vermeiden. Dieser Ansatz verbessert sowohl die Leistung als auch die Speichernutzung, indem die Notwendigkeit entfällt, so viele einzelne ArrayBuffer-Objekte zu verfolgen und aufzuräumen.

In dem Fall, dass ein Entwickler jedoch ein kleines Stück Speicher aus einem Pool für eine unbestimmte Zeit behalten muss, kann es angemessen sein, eine nicht gepoolte Buffer-Instanz unter Verwendung von Buffer.allocUnsafeSlow() zu erstellen und dann die relevanten Bits zu kopieren.

import { Buffer } from 'node:buffer';

// Need to keep around a few small chunks of memory.
const store = [];

socket.on('readable', () => {
  let data;
  while (null !== (data = readable.read())) {
    // Allocate for retained data.
    const sb = Buffer.allocUnsafeSlow(10);

    // Copy the data into the new allocation.
    data.copy(sb, 0, 0, 10);

    store.push(sb);
  }
});
const { Buffer } = require('node:buffer');

// Need to keep around a few small chunks of memory.
const store = [];

socket.on('readable', () => {
  let data;
  while (null !== (data = readable.read())) {
    // Allocate for retained data.
    const sb = Buffer.allocUnsafeSlow(10);

    // Copy the data into the new allocation.
    data.copy(sb, 0, 0, 10);

    store.push(sb);
  }
});
copy

Ein TypeError wird geworfen, wenn size keine Zahl ist.

Statische Methode: Buffer.byteLength(string[, encoding])#

• string <string> | <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <SharedArrayBuffer> Ein Wert, für den die Länge berechnet werden soll.
• encoding <string> Wenn string ein String ist, ist dies dessen Kodierung. Standard: 'utf8'.
• Gibt zurück: <integer> Die Anzahl der Bytes, die in string enthalten sind.

Gibt die Bytelänge eines Strings zurück, wenn dieser mit encoding kodiert ist. Dies ist nicht dasselbe wie String.prototype.length, das die Kodierung, die zum Konvertieren des Strings in Bytes verwendet wird, nicht berücksichtigt.

Für 'base64', 'base64url' und 'hex' geht diese Funktion von gültigen Eingaben aus. Für Strings, die nicht-base64/hex-kodierte Daten (z. B. Leerzeichen) enthalten, kann der Rückgabewert größer als die Länge eines aus dem String erstellten Buffer sein.

import { Buffer } from 'node:buffer';

const str = '\u00bd + \u00bc = \u00be';

console.log(`${str}: ${str.length} characters, ` +
            `${Buffer.byteLength(str, 'utf8')} bytes`);
// Prints: ½ + ¼ = ¾: 9 characters, 12 bytes
const { Buffer } = require('node:buffer');

const str = '\u00bd + \u00bc = \u00be';

console.log(`${str}: ${str.length} characters, ` +
            `${Buffer.byteLength(str, 'utf8')} bytes`);
// Prints: ½ + ¼ = ¾: 9 characters, 12 bytes
copy

Wenn string ein <Buffer> | <DataView> | <TypedArray> | <ArrayBuffer> | <SharedArrayBuffer> ist, wird die von .byteLength gemeldete Bytelänge zurückgegeben.

Statische Methode: Buffer.compare(buf1, buf2)#

• buf1 <Buffer> | <Uint8Array>
• buf2 <Buffer> | <Uint8Array>
• Gibt zurück: <integer> Entweder -1, 0 oder 1, abhängig vom Ergebnis des Vergleichs. Siehe buf.compare() für Details.

Vergleicht buf1 mit buf2, typischerweise zum Zwecke des Sortierens von Arrays aus Buffer-Instanzen. Dies entspricht dem Aufruf von buf1.compare(buf2).

import { Buffer } from 'node:buffer';

const buf1 = Buffer.from('1234');
const buf2 = Buffer.from('0123');
const arr = [buf1, buf2];

console.log(arr.sort(Buffer.compare));
// Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (This result is equal to: [buf2, buf1].)
const { Buffer } = require('node:buffer');

const buf1 = Buffer.from('1234');
const buf2 = Buffer.from('0123');
const arr = [buf1, buf2];

console.log(arr.sort(Buffer.compare));
// Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (This result is equal to: [buf2, buf1].)
copy

Statische Methode: Buffer.concat(list[, totalLength])#

• list <Buffer[]> | <Uint8Array[]> Liste von Buffer- oder <Uint8Array>-Instanzen zum Verketten.
• totalLength <integer> Gesamtlänge der Buffer-Instanzen in list, wenn verkettet.
• Rückgabewert: <Buffer>

Gibt einen neuen Buffer zurück, der das Ergebnis der Verkettung aller Buffer-Instanzen in der list ist.

Wenn die Liste keine Elemente enthält oder wenn totalLength 0 ist, wird ein neuer Buffer der Länge Null zurückgegeben.

Wenn totalLength nicht bereitgestellt wird, wird sie aus den Buffer-Instanzen in list durch Addieren ihrer Längen berechnet.

Wenn totalLength bereitgestellt wird, muss es eine Ganzzahl ohne Vorzeichen sein. Wenn die kombinierte Länge der Buffer in list totalLength überschreitet, wird das Ergebnis auf totalLength gekürzt. Wenn die kombinierte Länge der Buffer in list kleiner als totalLength ist, wird der verbleibende Raum mit Nullen gefüllt.

import { Buffer } from 'node:buffer';

// Create a single `Buffer` from a list of three `Buffer` instances.

const buf1 = Buffer.alloc(10);
const buf2 = Buffer.alloc(14);
const buf3 = Buffer.alloc(18);
const totalLength = buf1.length + buf2.length + buf3.length;

console.log(totalLength);
// Prints: 42

const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);

console.log(bufA);
// Prints: <Buffer 00 00 00 00 ...>
console.log(bufA.length);
// Prints: 42
const { Buffer } = require('node:buffer');

// Create a single `Buffer` from a list of three `Buffer` instances.

const buf1 = Buffer.alloc(10);
const buf2 = Buffer.alloc(14);
const buf3 = Buffer.alloc(18);
const totalLength = buf1.length + buf2.length + buf3.length;

console.log(totalLength);
// Prints: 42

const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);

console.log(bufA);
// Prints: <Buffer 00 00 00 00 ...>
console.log(bufA.length);
// Prints: 42
copy

Buffer.concat() kann ebenfalls den internen Buffer-Pool verwenden, wie es Buffer.allocUnsafe() tut.

Statische Methode: Buffer.copyBytesFrom(view[, offset[, length]])#

• view <TypedArray> Das zu kopierende <TypedArray>.
• offset <integer> Der Start-Offset innerhalb von view. Standard: 0.
• length <integer> Die Anzahl der Elemente aus view, die kopiert werden sollen. Standard: view.length - offset.
• Rückgabewert: <Buffer>

Kopiert den zugrunde liegenden Speicher von view in einen neuen Buffer.

const u16 = new Uint16Array([0, 0xffff]);
const buf = Buffer.copyBytesFrom(u16, 1, 1);
u16[1] = 0;
console.log(buf.length); // 2
console.log(buf[0]); // 255
console.log(buf[1]); // 255
copy

Statische Methode: Buffer.from(array)#

• array <integer[]>
• Rückgabewert: <Buffer>

Weist einen neuen Buffer unter Verwendung eines array von Bytes im Bereich 0 – 255 zu. Array-Einträge außerhalb dieses Bereichs werden abgeschnitten, um hineinzupassen.

import { Buffer } from 'node:buffer';

// Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
const { Buffer } = require('node:buffer');

// Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
copy

Wenn array ein array-ähnliches Objekt ist (d. h. eines mit einer length-Eigenschaft vom Typ number), wird es wie ein Array behandelt, es sei denn, es ist ein Buffer oder ein Uint8Array. Das bedeutet, dass alle anderen TypedArray-Varianten als Array behandelt werden. Um einen Buffer aus den Bytes zu erstellen, die ein TypedArray stützen, verwenden Sie Buffer.copyBytesFrom().

Ein TypeError wird geworfen, wenn array kein Array oder ein anderer für Buffer.from()-Varianten geeigneter Typ ist.

Buffer.from(array) und Buffer.from(string) können ebenfalls den internen Buffer-Pool verwenden, wie es Buffer.allocUnsafe() tut.

Statische Methode: Buffer.from(arrayBuffer[, byteOffset[, length]])#

• arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> Ein <ArrayBuffer>, <SharedArrayBuffer>, zum Beispiel die .buffer-Eigenschaft eines <TypedArray>.
• byteOffset <integer> Index des ersten freizulegenden Bytes. Standard: 0.
• length <integer> Anzahl der freizulegenden Bytes. Standard: arrayBuffer.byteLength - byteOffset.
• Rückgabewert: <Buffer>

Dies erstellt eine Ansicht des <ArrayBuffer>, ohne den zugrunde liegenden Speicher zu kopieren. Zum Beispiel, wenn eine Referenz auf die .buffer-Eigenschaft einer <TypedArray>-Instanz übergeben wird, teilt sich der neu erstellte Buffer denselben zugewiesenen Speicher wie der zugrunde liegende ArrayBuffer des <TypedArray>.

import { Buffer } from 'node:buffer';

const arr = new Uint16Array(2);

arr[0] = 5000;
arr[1] = 4000;

// Shares memory with `arr`.
const buf = Buffer.from(arr.buffer);

console.log(buf);
// Prints: <Buffer 88 13 a0 0f>

// Changing the original Uint16Array changes the Buffer also.
arr[1] = 6000;

console.log(buf);
// Prints: <Buffer 88 13 70 17>
const { Buffer } = require('node:buffer');

const arr = new Uint16Array(2);

arr[0] = 5000;
arr[1] = 4000;

// Shares memory with `arr`.
const buf = Buffer.from(arr.buffer);

console.log(buf);
// Prints: <Buffer 88 13 a0 0f>

// Changing the original Uint16Array changes the Buffer also.
arr[1] = 6000;

console.log(buf);
// Prints: <Buffer 88 13 70 17>
copy

Die optionalen Argumente byteOffset und length spezifizieren einen Speicherbereich innerhalb des arrayBuffer, der vom Buffer geteilt wird.

import { Buffer } from 'node:buffer';

const ab = new ArrayBuffer(10);
const buf = Buffer.from(ab, 0, 2);

console.log(buf.length);
// Prints: 2
const { Buffer } = require('node:buffer');

const ab = new ArrayBuffer(10);
const buf = Buffer.from(ab, 0, 2);

console.log(buf.length);
// Prints: 2
copy

Ein TypeError wird geworfen, wenn arrayBuffer kein <ArrayBuffer> oder <SharedArrayBuffer> oder ein anderer für Buffer.from()-Varianten geeigneter Typ ist.

Es ist wichtig, daran zu denken, dass ein zugrunde liegender ArrayBuffer einen Speicherbereich abdecken kann, der über die Grenzen einer TypedArray-Ansicht hinausgeht. Ein neuer Buffer, der unter Verwendung der buffer-Eigenschaft eines TypedArray erstellt wurde, kann über den Bereich des TypedArray hinausgehen

import { Buffer } from 'node:buffer';

const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements
const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
console.log(arrA.buffer === arrB.buffer); // true

const buf = Buffer.from(arrB.buffer);
console.log(buf);
// Prints: <Buffer 63 64 65 66>
const { Buffer } = require('node:buffer');

const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements
const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
console.log(arrA.buffer === arrB.buffer); // true

const buf = Buffer.from(arrB.buffer);
console.log(buf);
// Prints: <Buffer 63 64 65 66>
copy

Statische Methode: Buffer.from(buffer)#

• buffer <Buffer> | <Uint8Array> Ein existierender Buffer oder <Uint8Array>, aus dem Daten kopiert werden sollen.
• Rückgabewert: <Buffer>

Kopiert die übergebenen buffer-Daten auf eine neue Buffer-Instanz.

import { Buffer } from 'node:buffer';

const buf1 = Buffer.from('buffer');
const buf2 = Buffer.from(buf1);

buf1[0] = 0x61;

console.log(buf1.toString());
// Prints: auffer
console.log(buf2.toString());
// Prints: buffer
const { Buffer } = require('node:buffer');

const buf1 = Buffer.from('buffer');
const buf2 = Buffer.from(buf1);

buf1[0] = 0x61;

console.log(buf1.toString());
// Prints: auffer
console.log(buf2.toString());
// Prints: buffer
copy

Ein TypeError wird geworfen, wenn buffer kein Buffer oder ein anderer für Buffer.from()-Varianten geeigneter Typ ist.

Statische Methode: Buffer.from(object[, offsetOrEncoding[, length]])#

• object <Object> Ein Objekt, das Symbol.toPrimitive oder valueOf() unterstützt.
• offsetOrEncoding <integer> | <string> Ein Byte-Offset oder eine Kodierung.
• length <integer> Eine Länge.
• Rückgabewert: <Buffer>

Für Objekte, deren valueOf()-Funktion einen Wert zurückgibt, der nicht strikt gleich object ist, gibt es Buffer.from(object.valueOf(), offsetOrEncoding, length) zurück.

import { Buffer } from 'node:buffer';

const buf = Buffer.from(new String('this is a test'));
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>
const { Buffer } = require('node:buffer');

const buf = Buffer.from(new String('this is a test'));
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>
copy

Für Objekte, die Symbol.toPrimitive unterstützen, gibt es Buffer.from(object[Symbol.toPrimitive]('string'), offsetOrEncoding) zurück.

import { Buffer } from 'node:buffer';

class Foo {
  [Symbol.toPrimitive]() {
    return 'this is a test';
  }
}

const buf = Buffer.from(new Foo(), 'utf8');
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>
const { Buffer } = require('node:buffer');

class Foo {
  [Symbol.toPrimitive]() {
    return 'this is a test';
  }
}

const buf = Buffer.from(new Foo(), 'utf8');
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>
copy

Ein TypeError wird geworfen, wenn object die genannten Methoden nicht hat oder kein anderer für Buffer.from()-Varianten geeigneter Typ ist.

Statische Methode: Buffer.from(string[, encoding])#

• string <string> Ein zu kodierender String.
• encoding <string> Die Kodierung von string. Standard: 'utf8'.
• Rückgabewert: <Buffer>

Erstellt einen neuen Buffer, der string enthält. Der encoding-Parameter identifiziert die Zeichenkodierung, die beim Konvertieren von string in Bytes verwendet werden soll.

import { Buffer } from 'node:buffer';

const buf1 = Buffer.from('this is a tést');
const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');

console.log(buf1.toString());
// Prints: this is a tést
console.log(buf2.toString());
// Prints: this is a tést
console.log(buf1.toString('latin1'));
// Prints: this is a tést
const { Buffer } = require('node:buffer');

const buf1 = Buffer.from('this is a tést');
const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');

console.log(buf1.toString());
// Prints: this is a tést
console.log(buf2.toString());
// Prints: this is a tést
console.log(buf1.toString('latin1'));
// Prints: this is a tést
copy

Ein TypeError wird geworfen, wenn string kein String oder ein anderer für Buffer.from()-Varianten geeigneter Typ ist.

Buffer.from(string) kann ebenfalls den internen Buffer-Pool verwenden, wie es Buffer.allocUnsafe() tut.

Statische Methode: Buffer.isBuffer(obj)#

• obj <Object>
• Rückgabewert: <boolean>

Gibt true zurück, wenn obj ein Buffer ist, sonst false.

import { Buffer } from 'node:buffer';

Buffer.isBuffer(Buffer.alloc(10)); // true
Buffer.isBuffer(Buffer.from('foo')); // true
Buffer.isBuffer('a string'); // false
Buffer.isBuffer([]); // false
Buffer.isBuffer(new Uint8Array(1024)); // false
const { Buffer } = require('node:buffer');

Buffer.isBuffer(Buffer.alloc(10)); // true
Buffer.isBuffer(Buffer.from('foo')); // true
Buffer.isBuffer('a string'); // false
Buffer.isBuffer([]); // false
Buffer.isBuffer(new Uint8Array(1024)); // false
copy

Statische Methode: Buffer.isEncoding(encoding)#

• encoding <string> Ein Name einer Zeichenkodierung zur Überprüfung.
• Rückgabewert: <boolean>

Gibt true zurück, wenn encoding der Name einer unterstützten Zeichenkodierung ist, oder sonst false.

import { Buffer } from 'node:buffer';

console.log(Buffer.isEncoding('utf8'));
// Prints: true

console.log(Buffer.isEncoding('hex'));
// Prints: true

console.log(Buffer.isEncoding('utf/8'));
// Prints: false

console.log(Buffer.isEncoding(''));
// Prints: false
const { Buffer } = require('node:buffer');

console.log(Buffer.isEncoding('utf8'));
// Prints: true

console.log(Buffer.isEncoding('hex'));
// Prints: true

console.log(Buffer.isEncoding('utf/8'));
// Prints: false

console.log(Buffer.isEncoding(''));
// Prints: false
copy

Buffer.poolSize#

• Typ: <integer> Standard: 8192

Dies ist die Größe (in Bytes) der vorab zugewiesenen internen Buffer-Instanzen, die für das Pooling verwendet werden. Dieser Wert kann modifiziert werden.

buf[index]#

• index <integer>

Der Index-Operator [index] kann verwendet werden, um das Oktett an der Position index in buf abzurufen und zu setzen. Die Werte beziehen sich auf einzelne Bytes, daher liegt der zulässige Wertebereich zwischen 0x00 und 0xFF (hex) oder 0 und 255 (dezimal).

Dieser Operator wird von Uint8Array geerbt, daher ist sein Verhalten bei Zugriff außerhalb der Grenzen dasselbe wie bei Uint8Array. Mit anderen Worten, buf[index] gibt undefined zurück, wenn index negativ oder größer oder gleich buf.length ist, und buf[index] = value modifiziert den Puffer nicht, wenn index negativ ist oder >= buf.length.

import { Buffer } from 'node:buffer';

// Copy an ASCII string into a `Buffer` one byte at a time.
// (This only works for ASCII-only strings. In general, one should use
// `Buffer.from()` to perform this conversion.)

const str = 'Node.js';
const buf = Buffer.allocUnsafe(str.length);

for (let i = 0; i < str.length; i++) {
  buf[i] = str.charCodeAt(i);
}

console.log(buf.toString('utf8'));
// Prints: Node.js
const { Buffer } = require('node:buffer');

// Copy an ASCII string into a `Buffer` one byte at a time.
// (This only works for ASCII-only strings. In general, one should use
// `Buffer.from()` to perform this conversion.)

const str = 'Node.js';
const buf = Buffer.allocUnsafe(str.length);

for (let i = 0; i < str.length; i++) {
  buf[i] = str.charCodeAt(i);
}

console.log(buf.toString('utf8'));
// Prints: Node.js
copy

buf.buffer#

• Typ: <ArrayBuffer> Das zugrunde liegende ArrayBuffer-Objekt, auf dessen Basis dieses Buffer-Objekt erstellt wurde.

Es ist nicht garantiert, dass dieser ArrayBuffer exakt dem ursprünglichen Buffer entspricht. Siehe die Hinweise zu buf.byteOffset für Details.

import { Buffer } from 'node:buffer';

const arrayBuffer = new ArrayBuffer(16);
const buffer = Buffer.from(arrayBuffer);

console.log(buffer.buffer === arrayBuffer);
// Prints: true
const { Buffer } = require('node:buffer');

const arrayBuffer = new ArrayBuffer(16);
const buffer = Buffer.from(arrayBuffer);

console.log(buffer.buffer === arrayBuffer);
// Prints: true
copy

buf.byteOffset#

• Typ: <integer> Der byteOffset des zugrunde liegenden ArrayBuffer-Objekts des Buffer.

Beim Setzen von byteOffset in Buffer.from(ArrayBuffer, byteOffset, length), oder manchmal beim Zuweisen eines Buffer, der kleiner als Buffer.poolSize ist, beginnt der Puffer nicht bei einem Null-Offset auf dem zugrunde liegenden ArrayBuffer.

Dies kann Probleme verursachen, wenn direkt auf den zugrunde liegenden ArrayBuffer unter Verwendung von buf.buffer zugegriffen wird, da andere Teile des ArrayBuffer möglicherweise in keinem Zusammenhang mit dem Buffer-Objekt selbst stehen.

Ein häufiges Problem beim Erstellen eines TypedArray-Objekts, das seinen Speicher mit einem Buffer teilt, ist, dass man in diesem Fall den byteOffset korrekt angeben muss

import { Buffer } from 'node:buffer';

// Create a buffer smaller than `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);

// When casting the Node.js Buffer to an Int8Array, use the byteOffset
// to refer only to the part of `nodeBuffer.buffer` that contains the memory
// for `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);
const { Buffer } = require('node:buffer');

// Create a buffer smaller than `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);

// When casting the Node.js Buffer to an Int8Array, use the byteOffset
// to refer only to the part of `nodeBuffer.buffer` that contains the memory
// for `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);
copy

buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])#

• target <Buffer> | <Uint8Array> Ein Buffer oder <Uint8Array>, mit dem buf verglichen werden soll.
• targetStart <integer> Der Offset innerhalb von target, an dem der Vergleich beginnen soll. Standard: 0.
• targetEnd <integer> Der Offset innerhalb von target, an dem der Vergleich enden soll (nicht inklusive). Standard: target.length.
• sourceStart <integer> Der Offset innerhalb von buf, an dem der Vergleich beginnen soll. Standard: 0.
• sourceEnd <integer> Der Offset innerhalb von buf, an dem der Vergleich enden soll (nicht inklusive). Standard: buf.length.
• Gibt zurück: <integer>

Vergleicht buf mit target und gibt eine Zahl zurück, die angibt, ob buf in der Sortierreihenfolge vor, nach oder gleich target kommt. Der Vergleich basiert auf der tatsächlichen Sequenz von Bytes in jedem Buffer.

• 0 wird zurückgegeben, wenn target gleich buf ist
• 1 wird zurückgegeben, wenn target beim Sortieren vor buf kommen sollte.
• -1 wird zurückgegeben, wenn target beim Sortieren nach buf kommen sollte.

import { Buffer } from 'node:buffer';

const buf1 = Buffer.from('ABC');
const buf2 = Buffer.from('BCD');
const buf3 = Buffer.from('ABCD');

console.log(buf1.compare(buf1));
// Prints: 0
console.log(buf1.compare(buf2));
// Prints: -1
console.log(buf1.compare(buf3));
// Prints: -1
console.log(buf2.compare(buf1));
// Prints: 1
console.log(buf2.compare(buf3));
// Prints: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare));
// Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (This result is equal to: [buf1, buf3, buf2].)
const { Buffer } = require('node:buffer');

const buf1 = Buffer.from('ABC');
const buf2 = Buffer.from('BCD');
const buf3 = Buffer.from('ABCD');

console.log(buf1.compare(buf1));
// Prints: 0
console.log(buf1.compare(buf2));
// Prints: -1
console.log(buf1.compare(buf3));
// Prints: -1
console.log(buf2.compare(buf1));
// Prints: 1
console.log(buf2.compare(buf3));
// Prints: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare));
// Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (This result is equal to: [buf1, buf3, buf2].)
copy

Die optionalen Argumente targetStart, targetEnd, sourceStart und sourceEnd können verwendet werden, um den Vergleich auf spezifische Bereiche innerhalb von target bzw. buf zu beschränken.

import { Buffer } from 'node:buffer';

const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9]);
const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4]);

console.log(buf1.compare(buf2, 5, 9, 0, 4));
// Prints: 0
console.log(buf1.compare(buf2, 0, 6, 4));
// Prints: -1
console.log(buf1.compare(buf2, 5, 6, 5));
// Prints: 1
const { Buffer } = require('node:buffer');

const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9]);
const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4]);

console.log(buf1.compare(buf2, 5, 9, 0, 4));
// Prints: 0
console.log(buf1.compare(buf2, 0, 6, 4));
// Prints: -1
console.log(buf1.compare(buf2, 5, 6, 5));
// Prints: 1
copy

ERR_OUT_OF_RANGE wird geworfen, wenn targetStart < 0, sourceStart < 0, targetEnd > target.byteLength oder sourceEnd > source.byteLength.

buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])#

• target <Buffer> | <Uint8Array> Ein Buffer oder <Uint8Array>, in das kopiert werden soll.
• targetStart <integer> Der Offset innerhalb von target, an dem das Schreiben beginnen soll. Standard: 0.
• sourceStart <integer> Der Offset innerhalb von buf, ab dem das Kopieren beginnen soll. Standard: 0.
• sourceEnd <integer> Der Offset innerhalb von buf, an dem das Kopieren enden soll (nicht inklusive). Standard: buf.length.
• Gibt zurück: <integer> Die Anzahl der kopierten Bytes.

Kopiert Daten aus einer Region von buf in eine Region in target, selbst wenn der Speicherbereich von target mit buf überlappt.

TypedArray.prototype.set() führt dieselbe Operation aus und ist für alle TypedArrays verfügbar, einschließlich Node.js Buffer, obwohl es andere Funktionsargumente annimmt.

import { Buffer } from 'node:buffer';

// Create two `Buffer` instances.
const buf1 = Buffer.allocUnsafe(26);
const buf2 = Buffer.allocUnsafe(26).fill('!');

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf1[i] = i + 97;
}

// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.
buf1.copy(buf2, 8, 16, 20);
// This is equivalent to:
// buf2.set(buf1.subarray(16, 20), 8);

console.log(buf2.toString('ascii', 0, 25));
// Prints: !!!!!!!!qrst!!!!!!!!!!!!!
const { Buffer } = require('node:buffer');

// Create two `Buffer` instances.
const buf1 = Buffer.allocUnsafe(26);
const buf2 = Buffer.allocUnsafe(26).fill('!');

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf1[i] = i + 97;
}

// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.
buf1.copy(buf2, 8, 16, 20);
// This is equivalent to:
// buf2.set(buf1.subarray(16, 20), 8);

console.log(buf2.toString('ascii', 0, 25));
// Prints: !!!!!!!!qrst!!!!!!!!!!!!!
copy

import { Buffer } from 'node:buffer';

// Create a `Buffer` and copy data from one region to an overlapping region
// within the same `Buffer`.

const buf = Buffer.allocUnsafe(26);

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf[i] = i + 97;
}

buf.copy(buf, 0, 4, 10);

console.log(buf.toString());
// Prints: efghijghijklmnopqrstuvwxyz
const { Buffer } = require('node:buffer');

// Create a `Buffer` and copy data from one region to an overlapping region
// within the same `Buffer`.

const buf = Buffer.allocUnsafe(26);

for (let i = 0; i < 26; i++) {
  // 97 is the decimal ASCII value for 'a'.
  buf[i] = i + 97;
}

buf.copy(buf, 0, 4, 10);

console.log(buf.toString());
// Prints: efghijghijklmnopqrstuvwxyz
copy

buf.entries()#

• Gibt zurück: <Iterator>

Erstellt und gibt einen Iterator von [index, byte]-Paaren aus dem Inhalt von buf zurück.

import { Buffer } from 'node:buffer';

// Log the entire contents of a `Buffer`.

const buf = Buffer.from('buffer');

for (const pair of buf.entries()) {
  console.log(pair);
}
// Prints:
//   [0, 98]
//   [1, 117]
//   [2, 102]
//   [3, 102]
//   [4, 101]
//   [5, 114]
const { Buffer } = require('node:buffer');

// Log the entire contents of a `Buffer`.

const buf = Buffer.from('buffer');

for (const pair of buf.entries()) {
  console.log(pair);
}
// Prints:
//   [0, 98]
//   [1, 117]
//   [2, 102]
//   [3, 102]
//   [4, 101]
//   [5, 114]
copy

buf.equals(otherBuffer)#

• otherBuffer <Buffer> | <Uint8Array> Ein Buffer oder <Uint8Array>, mit dem buf verglichen werden soll.
• Rückgabewert: <boolean>

Gibt true zurück, wenn sowohl buf als auch otherBuffer exakt dieselben Bytes haben, sonst false. Entspricht buf.compare(otherBuffer) === 0.

import { Buffer } from 'node:buffer';

const buf1 = Buffer.from('ABC');
const buf2 = Buffer.from('414243', 'hex');
const buf3 = Buffer.from('ABCD');

console.log(buf1.equals(buf2));
// Prints: true
console.log(buf1.equals(buf3));
// Prints: false
const { Buffer } = require('node:buffer');

const buf1 = Buffer.from('ABC');
const buf2 = Buffer.from('414243', 'hex');
const buf3 = Buffer.from('ABCD');

console.log(buf1.equals(buf2));
// Prints: true
console.log(buf1.equals(buf3));
// Prints: false
copy

buf.fill(value[, offset[, end]][, encoding])#

• value <string> | <Buffer> | <Uint8Array> | <integer> Der Wert, mit dem buf gefüllt werden soll. Ein leerer Wert (String, Uint8Array, Buffer) wird zu 0 gezwungen.
• offset <integer> Anzahl der Bytes, die übersprungen werden sollen, bevor mit dem Füllen von buf begonnen wird. Standard: 0.
• end <integer> Wo das Füllen von buf gestoppt werden soll (nicht inklusive). Standard: buf.length.
• encoding <string> Die Kodierung für value, wenn value ein String ist. Standard: 'utf8'.
• Gibt zurück: <Buffer> Eine Referenz auf buf.

Füllt buf mit dem angegebenen value. Wenn offset und end nicht angegeben sind, wird der gesamte buf gefüllt

import { Buffer } from 'node:buffer';

// Fill a `Buffer` with the ASCII character 'h'.

const b = Buffer.allocUnsafe(50).fill('h');

console.log(b.toString());
// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

// Fill a buffer with empty string
const c = Buffer.allocUnsafe(5).fill('');

console.log(c.fill(''));
// Prints: <Buffer 00 00 00 00 00>
const { Buffer } = require('node:buffer');

// Fill a `Buffer` with the ASCII character 'h'.

const b = Buffer.allocUnsafe(50).fill('h');

console.log(b.toString());
// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

// Fill a buffer with empty string
const c = Buffer.allocUnsafe(5).fill('');

console.log(c.fill(''));
// Prints: <Buffer 00 00 00 00 00>
copy

value wird zu einem uint32-Wert gezwungen, wenn es kein String, Buffer oder eine Ganzzahl ist. Wenn die resultierende Ganzzahl größer als 255 (dezimal) ist, wird buf mit value & 255 gefüllt.

Wenn das letzte Schreiben eines fill()-Vorgangs auf ein Multi-Byte-Zeichen fällt, dann werden nur die Bytes dieses Zeichens geschrieben, die in buf passen

import { Buffer } from 'node:buffer';

// Fill a `Buffer` with character that takes up two bytes in UTF-8.

console.log(Buffer.allocUnsafe(5).fill('\u0222'));
// Prints: <Buffer c8 a2 c8 a2 c8>
const { Buffer } = require('node:buffer');

// Fill a `Buffer` with character that takes up two bytes in UTF-8.

console.log(Buffer.allocUnsafe(5).fill('\u0222'));
// Prints: <Buffer c8 a2 c8 a2 c8>
copy

Wenn value ungültige Zeichen enthält, wird es abgeschnitten; wenn keine gültigen Fülldaten verbleiben, wird eine Exception geworfen

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(5);

console.log(buf.fill('a'));
// Prints: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'));
// Prints: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'));
// Throws an exception.
const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(5);

console.log(buf.fill('a'));
// Prints: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'));
// Prints: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'));
// Throws an exception.
copy

buf.includes(value[, byteOffset][, encoding])#

• value <string> | <Buffer> | <Uint8Array> | <integer> Wonach gesucht werden soll.
• byteOffset <integer> Wo in buf mit der Suche begonnen werden soll. Wenn negativ, wird der Offset vom Ende von buf aus berechnet. Standard: 0.
• encoding <string> Wenn value ein String ist, ist dies dessen Kodierung. Standard: 'utf8'.
• Gibt zurück: <boolean> true, wenn value in buf gefunden wurde, sonst false.

Entspricht buf.indexOf() !== -1.

import { Buffer } from 'node:buffer';

const buf = Buffer.from('this is a buffer');

console.log(buf.includes('this'));
// Prints: true
console.log(buf.includes('is'));
// Prints: true
console.log(buf.includes(Buffer.from('a buffer')));
// Prints: true
console.log(buf.includes(97));
// Prints: true (97 is the decimal ASCII value for 'a')
console.log(buf.includes(Buffer.from('a buffer example')));
// Prints: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));
// Prints: true
console.log(buf.includes('this', 4));
// Prints: false
const { Buffer } = require('node:buffer');

const buf = Buffer.from('this is a buffer');

console.log(buf.includes('this'));
// Prints: true
console.log(buf.includes('is'));
// Prints: true
console.log(buf.includes(Buffer.from('a buffer')));
// Prints: true
console.log(buf.includes(97));
// Prints: true (97 is the decimal ASCII value for 'a')
console.log(buf.includes(Buffer.from('a buffer example')));
// Prints: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));
// Prints: true
console.log(buf.includes('this', 4));
// Prints: false
copy

buf.indexOf(value[, byteOffset][, encoding])#

• value <string> | <Buffer> | <Uint8Array> | <integer> Wonach gesucht werden soll.
• byteOffset <integer> Wo in buf mit der Suche begonnen werden soll. Wenn negativ, wird der Offset vom Ende von buf aus berechnet. Standard: 0.
• encoding <string> Wenn value ein String ist, ist dies die Kodierung, die verwendet wird, um die Binärdarstellung des Strings zu bestimmen, nach der in buf gesucht wird. Standard: 'utf8'.
• Gibt zurück: <integer> Der Index des ersten Vorkommens von value in buf, oder -1, wenn buf keinen value enthält.

Wenn value ist

• ein String, wird value gemäß der Zeichenkodierung in encoding interpretiert.
• ein Buffer oder <Uint8Array>, wird value in seiner Gesamtheit verwendet. Um einen teilweisen Buffer zu vergleichen, verwenden Sie buf.subarray.
• eine Zahl, wird value als eine Ganzzahl ohne Vorzeichen von 8 Bit zwischen 0 und 255 interpretiert.

import { Buffer } from 'node:buffer';

const buf = Buffer.from('this is a buffer');

console.log(buf.indexOf('this'));
// Prints: 0
console.log(buf.indexOf('is'));
// Prints: 2
console.log(buf.indexOf(Buffer.from('a buffer')));
// Prints: 8
console.log(buf.indexOf(97));
// Prints: 8 (97 is the decimal ASCII value for 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')));
// Prints: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));
// Prints: 8

const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le');

console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'));
// Prints: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'));
// Prints: 6
const { Buffer } = require('node:buffer');

const buf = Buffer.from('this is a buffer');

console.log(buf.indexOf('this'));
// Prints: 0
console.log(buf.indexOf('is'));
// Prints: 2
console.log(buf.indexOf(Buffer.from('a buffer')));
// Prints: 8
console.log(buf.indexOf(97));
// Prints: 8 (97 is the decimal ASCII value for 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')));
// Prints: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));
// Prints: 8

const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le');

console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'));
// Prints: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'));
// Prints: 6
copy