Buffer

[Stabil: 2 - Stabil]

Stabil: 2 Stabilität: 2 - Stabil

Quellcode: lib/buffer.js

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

Die Buffer-Klasse ist eine Unterklasse von JavaScript's Uint8Array-Klasse und erweitert sie um Methoden, die zusätzliche Anwendungsfälle abdecken. Node.js-APIs akzeptieren auch einfache Uint8Arrays, wo immer Buffers unterstützt werden.

Obwohl die Buffer-Klasse im globalen Scope verfügbar ist, wird dennoch empfohlen, explizit über eine Import- oder Require-Anweisung darauf zu verweisen.

ESM

import { Buffer } from 'node:buffer'

// Erstellt einen mit Null gefüllten Buffer der Länge 10.
const buf1 = Buffer.alloc(10)

// Erstellt einen Buffer der Länge 10,
// gefüllt mit Bytes, die alle den Wert `1` haben.
const buf2 = Buffer.alloc(10, 1)

// Erstellt einen nicht initialisierten Buffer der Länge 10.
// Dies ist schneller als der Aufruf von Buffer.alloc(), aber die zurückgegebene
// Buffer-Instanz kann alte Daten enthalten, die überschrieben werden müssen,
// indem fill(), write() oder andere Funktionen verwendet werden, die den Inhalt des Buffers füllen.
const buf3 = Buffer.allocUnsafe(10)

// Erstellt einen Buffer, der die Bytes [1, 2, 3] enthält.
const buf4 = Buffer.from([1, 2, 3])

// Erstellt einen Buffer, der die Bytes [1, 1, 1, 1] enthält – die Einträge
// werden alle mit `(value & 255)` abgeschnitten, um in den Bereich 0–255 zu passen.
const buf5 = Buffer.from([257, 257.5, -255, '1'])

// Erstellt einen Buffer, der die UTF-8-codierten Bytes für die Zeichenkette 'tést' enthält:
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadezimaler Notation)
// [116, 195, 169, 115, 116] (in dezimaler Notation)
const buf6 = Buffer.from('tést')

// Erstellt einen Buffer, der die Latin-1-Bytes [0x74, 0xe9, 0x73, 0x74] enthält.
const buf7 = Buffer.from('tést', 'latin1')

CJS

const { Buffer } = require('node:buffer')

// Erstellt einen mit Null gefüllten Buffer der Länge 10.
const buf1 = Buffer.alloc(10)

// Erstellt einen Buffer der Länge 10,
// gefüllt mit Bytes, die alle den Wert `1` haben.
const buf2 = Buffer.alloc(10, 1)

// Erstellt einen nicht initialisierten Buffer der Länge 10.
// Dies ist schneller als der Aufruf von Buffer.alloc(), aber die zurückgegebene
// Buffer-Instanz kann alte Daten enthalten, die überschrieben werden müssen,
// indem fill(), write() oder andere Funktionen verwendet werden, die den Inhalt des Buffers füllen.
const buf3 = Buffer.allocUnsafe(10)

// Erstellt einen Buffer, der die Bytes [1, 2, 3] enthält.
const buf4 = Buffer.from([1, 2, 3])

// Erstellt einen Buffer, der die Bytes [1, 1, 1, 1] enthält – die Einträge
// werden alle mit `(value & 255)` abgeschnitten, um in den Bereich 0–255 zu passen.
const buf5 = Buffer.from([257, 257.5, -255, '1'])

// Erstellt einen Buffer, der die UTF-8-codierten Bytes für die Zeichenkette 'tést' enthält:
// [0x74, 0xc3, 0xa9, 0x73, 0x74] (in hexadezimaler Notation)
// [116, 195, 169, 115, 116] (in dezimaler Notation)
const buf6 = Buffer.from('tést')

// Erstellt einen Buffer, der die Latin-1-Bytes [0x74, 0xe9, 0x73, 0x74] enthält.
const buf7 = Buffer.from('tést', 'latin1')

Puffer und Zeichenkodierungen

[Verlauf]

Version	Änderungen
v15.7.0, v14.18.0	Einführung der base64url-Kodierung.
v6.4.0	Einführung von latin1 als Alias für binary.
v5.0.0	Entfernung der veralteten raw und raws Kodierungen.

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

ESM

import { Buffer } from 'node:buffer'

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

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

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

CJS

const { Buffer } = require('node:buffer')

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

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

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

Node.js Puffer akzeptieren alle Schreibweisen von Kodierungsstrings, die sie empfangen. UTF-8 kann beispielsweise als 'utf8', 'UTF8' oder 'uTf8' angegeben werden.

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

• 'utf8' (Alias: 'utf-8'): Mehrbyte-kodierte Unicode-Zeichen. Viele Webseiten und andere Dokumentformate verwenden UTF-8. Dies ist die Standardzeichenkodierung. Beim Dekodieren eines Buffer in einen String, der nicht ausschließlich gültige UTF-8-Daten enthält, wird das Unicode-Ersetzungszeichen U+FFFD � verwendet, um diese Fehler darzustellen.
• 'utf16le' (Alias: 'utf-16le'): Mehrbyte-kodierte Unicode-Zeichen. Im Gegensatz zu 'utf8' wird jedes Zeichen im String entweder 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 die Unicode-Zeichen von U+0000 bis U+00FF. Jedes Zeichen wird mit einem einzelnen Byte kodiert. Zeichen, die nicht in diesen Bereich passen, werden abgeschnitten und auf Zeichen in diesem Bereich abgebildet.

Die Konvertierung eines Buffer in einen String mit einer der oben genannten Methoden wird als Dekodierung bezeichnet, und die Konvertierung eines Strings in einen Buffer als Kodierung.

Node.js unterstützt auch die folgenden Binär-zu-Text-Kodierungen. Bei Binär-zu-Text-Kodierungen ist die Namenskonvention umgekehrt: Die Konvertierung eines Buffer in einen String wird typischerweise als Kodierung bezeichnet, und die Konvertierung eines Strings in einen Buffer als Dekodierung.

• 'base64': Base64-Kodierung. Beim Erstellen eines Buffer aus einem String akzeptiert diese Kodierung auch korrekt das "URL and Filename Safe Alphabet", wie in RFC 4648, Abschnitt 5 spezifiziert. Leerzeichen wie Leerzeichen, Tabulatoren 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 korrekt reguläre base64-kodierte Strings. Beim Kodieren eines Buffer in einen String lässt diese Kodierung die Auffüllung weg.
• 'hex': Jedes Byte wird als zwei hexadezimale Zeichen kodiert. Datenverlust kann auftreten, wenn Strings dekodiert werden, die nicht ausschließlich aus einer geraden Anzahl hexadezimaler Zeichen bestehen. Siehe unten für ein Beispiel.

Die folgenden Legacy-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 diese Kodierung zusätzlich das höchste Bit jedes Bytes, bevor sie als 'latin1' dekodiert wird. Im Allgemeinen sollte es keinen Grund geben, diese Kodierung zu verwenden, da 'utf8' (oder, wenn die Daten bekanntermaßen immer nur ASCII sind, 'latin1') eine bessere Wahl beim Kodieren oder Dekodieren von rein 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 Buffers ist typischerweise 'utf8' die richtige Wahl.
• 'ucs2', 'ucs-2': Aliase von '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.

ESM

import { Buffer } from 'node:buffer'

Buffer.from('1ag123', 'hex')
// Gibt <Buffer 1a> aus, Daten abgeschnitten, wenn der erste nicht-hexadezimale Wert
// ('g') angetroffen wird.

Buffer.from('1a7', 'hex')
// Gibt <Buffer 1a> aus, Daten abgeschnitten, wenn die Daten mit einer einzelnen Ziffer ('7') enden.

Buffer.from('1634', 'hex')
// Gibt <Buffer 16 34> aus, alle Daten dargestellt.

CJS

const { Buffer } = require('node:buffer')

Buffer.from('1ag123', 'hex')
// Gibt <Buffer 1a> aus, Daten abgeschnitten, wenn der erste nicht-hexadezimale Wert
// ('g') angetroffen wird.

Buffer.from('1a7', 'hex')
// Gibt <Buffer 1a> aus, Daten abgeschnitten, wenn die Daten mit einer einzelnen Ziffer ('7') enden.

Buffer.from('1634', 'hex')
// Gibt <Buffer 16 34> aus, alle Daten dargestellt.

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

Puffer und TypedArrays

[Historie]

Version	Änderungen
v3.0.0	Die Buffer-Klasse erbt jetzt von Uint8Array.

Buffer-Instanzen sind auch JavaScript Uint8Array und TypedArray-Instanzen. Alle TypedArray-Methoden sind für 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 des bestehenden Buffer ohne Kopie. 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 für Buffer als auch für andere TypedArray zu erreichen und sollte bevorzugt werden.
• buf.toString() ist nicht kompatibel 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 eine Bytefolge des Zieltyps.

ESM

import { Buffer } from 'node:buffer'

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

console.log(uint32array)

// Gibt aus: Uint32Array(4) [ 1, 2, 3, 4 ]

CJS

const { Buffer } = require('node:buffer')

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

console.log(uint32array)

// Gibt aus: Uint32Array(4) [ 1, 2, 3, 4 ]

• Das Übergeben des zugrunde liegenden ArrayBuffer des Buffer erstellt einen TypedArray, der seinen Speicher mit dem Buffer teilt.

ESM

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)

// Gibt aus: Uint16Array(5) [ 104, 101, 108, 108, 111 ]

CJS

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)

// Gibt aus: Uint16Array(5) [ 104, 101, 108, 108, 111 ]

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

ESM

import { Buffer } from 'node:buffer'

const arr = new Uint16Array(2)

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

// Kopiert den Inhalt von `arr`.
const buf1 = Buffer.from(arr)

// Teilt den Speicher mit `arr`.
const buf2 = Buffer.from(arr.buffer)

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

arr[1] = 6000

console.log(buf1)
// Gibt aus: <Buffer 88 a0>
console.log(buf2)
// Gibt aus: <Buffer 88 13 70 17>

CJS

const { Buffer } = require('node:buffer')

const arr = new Uint16Array(2)

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

// Kopiert den Inhalt von `arr`.
const buf1 = Buffer.from(arr)

// Teilt den Speicher mit `arr`.
const buf2 = Buffer.from(arr.buffer)

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

arr[1] = 6000

console.log(buf1)
// Gibt aus: <Buffer 88 a0>
console.log(buf2)
// Gibt aus: <Buffer 88 13 70 17>

Bei der Erstellung eines Buffer mit dem .buffer eines TypedArray ist es möglich, nur einen Teil des zugrunde liegenden ArrayBuffer zu verwenden, indem die Parameter byteOffset und length übergeben werden.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.length)
// Gibt aus: 16

CJS

const { Buffer } = require('node:buffer')

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

console.log(buf.length)
// Gibt aus: 16

Buffer.from() und TypedArray.from() haben unterschiedliche Signaturen und Implementierungen. Insbesondere akzeptieren die TypedArray-Varianten ein zweites Argument, das eine Mapping-Funktion ist, die für jedes Element des Typisierten Arrays 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])

Puffer und Iteration

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

ESM

import { Buffer } from 'node:buffer'

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

for (const b of buf) {
  console.log(b)
}
// Gibt aus:
//   1
//   2
//   3

CJS

const { Buffer } = require('node:buffer')

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

for (const b of buf) {
  console.log(b)
}
// Gibt aus:
//   1
//   2
//   3

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

Klasse: Blob

[Versionsgeschichte]

Version	Änderungen
v18.0.0, v16.17.0	Nicht mehr experimentell.
v15.7.0, v14.18.0	Hinzugefügt in: v15.7.0, v14.18.0

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

new buffer.Blob([quellen[, optionen]])

[Versionsgeschichte]

Version	Änderungen
v16.7.0	Die Standardoption endings zum Ersetzen von Zeilenumbrüchen wurde hinzugefügt und die nicht standardmäßige Option encoding entfernt.
v15.7.0, v14.18.0	Hinzugefügt in: v15.7.0, v14.18.0

• quellen <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> Ein Array von String-, <ArrayBuffer>-, <TypedArray>-, <DataView>- oder <Blob>-Objekten, oder eine beliebige Mischung solcher Objekte, die im Blob gespeichert werden.
• optionen <Object>
  • endings <string> Einer von entweder 'transparent' oder 'native'. Wenn auf 'native' gesetzt, werden Zeilenumbrüche in String-Quellteilen in den plattformspezifischen Zeilenumbruch konvertiert, wie von require('node:os').EOL angegeben.
  • type <string> Der Blob-Content-Type. Die Absicht ist, dass type den MIME-Medientyp der Daten vermittelt, aber es wird 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-Bytefolgen codiert und in den Blob kopiert. Nicht übereinstimmende Surrogate-Paare innerhalb jedes String-Teils werden durch Unicode U+FFFD-Ersatzzeichen ersetzt.

blob.arrayBuffer()

Hinzugefügt in: v15.7.0, v14.18.0

• Rückgabewert: <Promise>

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

blob.bytes()

Hinzugefügt in: v22.3.0, v20.16.0

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

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

blob.size

Hinzugefügt in: v15.7.0, v14.18.0

Die Gesamtgröße des Blob in Bytes.

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

Hinzugefügt in: v15.7.0, v14.18.0

• start <number> Der Startindex.
• end <number> Der Endindex.
• type <string> Der Content-Type für den neuen Blob

Erstellt und gibt einen neuen Blob zurück, der einen Teilmenge der Daten dieses Blob-Objekts enthält. Der ursprüngliche Blob wird nicht verändert.

blob.stream()

Hinzugefügt in: v16.7.0

• Rückgabewert: <ReadableStream>

Gibt einen neuen ReadableStream zurück, der das Lesen des Inhalts des Blob ermöglicht.

blob.text()

Hinzugefügt in: v15.7.0, v14.18.0

• Rückgabewert: <Promise>

Gibt ein Promise zurück, das mit dem Inhalt des Blob aufgelöst wird, der als UTF-8-Zeichenkette dekodiert wurde.

blob.type

Hinzugefügt in: v15.7.0, v14.18.0

• Typ: <string>

Der Content-Type des Blob.

Blob-Objekte und MessageChannel

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

ESM

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)

// Der Blob ist nach dem Posten weiterhin verwendbar.
blob.text().then(console.log)

CJS

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)

// Der Blob ist nach dem Posten weiterhin verwendbar.
blob.text().then(console.log)

Klasse: Buffer

Die Klasse Buffer ist ein globaler Typ für die direkte Behandlung binärer Daten. Sie kann auf verschiedene Weisen konstruiert werden.

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

[Verlauf]

Version	Änderungen
v20.0.0	ERR_INVALID_ARG_TYPE oder ERR_OUT_OF_RANGE anstelle von ERR_INVALID_ARG_VALUE für ungültige Eingabeargumente ausgeben.
v15.0.0	ERR_INVALID_ARG_VALUE anstelle von ERR_INVALID_OPT_VALUE für ungültige Eingabeargumente ausgeben.
v10.0.0	Der Versuch, einen Puffer mit einer Länge ungleich Null mit einem Puffer mit einer Länge Null zu füllen, löst eine Ausnahme aus.
v10.0.0	Die Angabe einer ungültigen Zeichenkette für fill löst eine Ausnahme aus.
v8.9.3	Die Angabe einer ungültigen Zeichenkette für fill führt jetzt zu einem mit Null gefüllten Puffer.
v5.10.0	Hinzugefügt in: v5.10.0

• size <integer> Die gewünschte Länge des neuen Buffer.
• fill <string> | <Buffer> | <Uint8Array> | <integer> Ein Wert, mit dem der neue Buffer vorab gefüllt werden soll. Standard: 0.
• encoding <string> Wenn fill eine Zeichenkette ist, ist dies deren Codierung. Standard: 'utf8'.
• Rückgabewert: <Buffer>

Weist einen neuen Buffer mit size Bytes zu. Wenn fill undefined ist, wird der Buffer mit Null gefüllt.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.alloc(5)

console.log(buf)
// Gibt aus: <Buffer 00 00 00 00 00>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.alloc(5)

console.log(buf)
// Gibt aus: <Buffer 00 00 00 00 00>

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

Wenn fill angegeben ist, wird der zugewiesene Buffer initialisiert, indem buf.fill(fill) aufgerufen wird.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf)
// Gibt aus: <Buffer 61 61 61 61 61>

CJS

const { Buffer } = require('node:buffer')

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

console.log(buf)
// Gibt aus: <Buffer 61 61 61 61 61>

Wenn sowohl fill als auch encoding angegeben sind, wird der zugewiesene Buffer initialisiert, indem buf.fill(fill, encoding) aufgerufen wird.

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

const { Buffer } = require('node:buffer')

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

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

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 vorherigen Zuweisungen enthält, einschließlich Daten, die möglicherweise nicht für Buffers zugewiesen wurden.

Ein TypeError wird ausgelöst, wenn size keine Zahl ist.

Statische Methode: Buffer.allocUnsafe(size)

[Verlauf]

Version	Änderungen
v20.0.0	ERR_INVALID_ARG_TYPE oder ERR_OUT_OF_RANGE wird anstelle von ERR_INVALID_ARG_VALUE für ungültige Eingabeargumente geworfen.
v15.0.0	ERR_INVALID_ARG_VALUE wird anstelle von ERR_INVALID_OPT_VALUE für ungültige Eingabeargumente geworfen.
v7.0.0	Das Übergeben einer negativen size-Größe löst nun einen Fehler aus.
v5.10.0	Hinzugefügt in: v5.10.0

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

Alloziert einen neuen Buffer mit size Bytes. 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.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(10)

console.log(buf)
// Gibt aus (Inhalt kann variieren): <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0)

console.log(buf)
// Gibt aus: <Buffer 00 00 00 00 00 00 00 00 00 00>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(10)

console.log(buf)
// Gibt aus (Inhalt kann variieren): <Buffer a0 8b 28 3f 01 00 00 00 50 32>

buf.fill(0)

console.log(buf)
// Gibt aus: <Buffer 00 00 00 00 00 00 00 00 00 00>

Ein TypeError wird geworfen, wenn size keine Zahl ist.

Das Buffer-Modul pre-alloziert eine interne Buffer-Instanz der Größe Buffer.poolSize, die als Pool für die schnelle Allokation neuer Buffer-Instanzen verwendet wird, die mit Buffer.allocUnsafe(), Buffer.from(array), Buffer.from(string) und Buffer.concat() erstellt werden, nur wenn size kleiner als Buffer.poolSize \>\>\> 1 (floor von Buffer.poolSize dividiert durch zwei) ist.

Die Verwendung dieses vorallozierten internen Speicherpools ist ein wesentlicher Unterschied zwischen dem Aufruf von Buffer.alloc(size, fill) und Buffer.allocUnsafe(size).fill(fill). Genauer gesagt, Buffer.alloc(size, fill) wird den internen Buffer-Pool nie verwenden, während Buffer.allocUnsafe(size).fill(fill) den internen Buffer-Pool wird verwenden, 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)

[Verlauf]

Version	Änderungen
v20.0.0	ERR_INVALID_ARG_TYPE oder ERR_OUT_OF_RANGE wird anstelle von ERR_INVALID_ARG_VALUE für ungültige Eingabeargumente ausgelöst.
v15.0.0	ERR_INVALID_ARG_VALUE wird anstelle von ERR_INVALID_OPT_VALUE für ungültige Eingabeargumente ausgelöst.
v5.12.0	Hinzugefügt in: v5.12.0

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

Alloziert einen neuen Buffer mit size Bytes. Wenn size größer als buffer.constants.MAX_LENGTH oder kleiner als 0 ist, wird ERR_OUT_OF_RANGE ausgelöst. 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() zum Allozieren neuer Buffer-Instanzen werden Allokationen von weniger als Buffer.poolSize \>\>\> 1 (4 KiB bei Verwendung der Standard-poolSize) aus einem einzigen vorallozierten Buffer geschnitten. Dies ermöglicht es Anwendungen, den Garbage-Collection-Overhead zu vermeiden, der durch das Erstellen vieler einzeln allozierter Buffer-Instanzen entsteht. Dieser Ansatz verbessert sowohl die Leistung als auch die Speichernutzung, indem die Notwendigkeit, viele einzelne ArrayBuffer-Objekte zu verfolgen und bereinigen, eliminiert wird.

Wenn ein Entwickler jedoch möglicherweise einen kleinen Speicherbereich aus einem Pool für eine unbestimmte Zeit beibehalten muss, kann es angebracht sein, eine nicht gepoolte Buffer-Instanz mit Buffer.allocUnsafeSlow() zu erstellen und dann die relevanten Bits zu kopieren.

ESM

import { Buffer } from 'node:buffer'

// Einige kleine Speicherblöcke müssen beibehalten werden.
const store = []

socket.on('readable', () => {
  let data
  while (null !== (data = readable.read())) {
    // Allokation für beibehaltene Daten.
    const sb = Buffer.allocUnsafeSlow(10)

    // Kopiere die Daten in die neue Allokation.
    data.copy(sb, 0, 0, 10)

    store.push(sb)
  }
})

CJS

const { Buffer } = require('node:buffer')

// Einige kleine Speicherblöcke müssen beibehalten werden.
const store = []

socket.on('readable', () => {
  let data
  while (null !== (data = readable.read())) {
    // Allokation für beibehaltene Daten.
    const sb = Buffer.allocUnsafeSlow(10)

    // Kopiere die Daten in die neue Allokation.
    data.copy(sb, 0, 0, 10)

    store.push(sb)
  }
})

Ein TypeError wird ausgelöst, wenn size keine Zahl ist.

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

[Verlauf]

Version	Änderungen
v7.0.0	Ungültige Eingaben führen jetzt zu einem Fehler.
v5.10.0	Der Parameter string kann jetzt ein beliebiges TypedArray, DataView oder ArrayBuffer sein.
v0.1.90	Hinzugefügt in: v0.1.90

• string <string> | <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <SharedArrayBuffer> Ein Wert, dessen Länge berechnet werden soll.
• encoding <string> Wenn string eine Zeichenkette ist, ist dies deren Codierung. Standard: 'utf8'.
• Rückgabewert: <integer> Die Anzahl der Bytes in string.

Gibt die Bytelänge einer Zeichenkette zurück, wenn sie mit encoding codiert ist. Dies ist nicht dasselbe wie String.prototype.length, das die zur Umwandlung der Zeichenkette in Bytes verwendete Codierung nicht berücksichtigt.

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

ESM

import { Buffer } from 'node:buffer'

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

console.log(`${str}: ${str.length} Zeichen, ` + `${Buffer.byteLength(str, 'utf8')} Bytes`)
// Gibt aus: ½ + ¼ = ¾: 9 Zeichen, 12 Bytes

CJS

const { Buffer } = require('node:buffer')

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

console.log(`${str}: ${str.length} Zeichen, ` + `${Buffer.byteLength(str, 'utf8')} Bytes`)
// Gibt aus: ½ + ¼ = ¾: 9 Zeichen, 12 Bytes

Wenn string ein Buffer/DataView/TypedArray/ArrayBuffer/SharedArrayBuffer ist, wird die von .byteLength angegebene Bytelänge zurückgegeben.

Statische Methode: Buffer.compare(buf1, buf2)

[Verlauf]

Version	Änderungen
v8.0.0	Die Argumente können jetzt Uint8Arrays sein.
v0.11.13	Hinzugefügt in: v0.11.13

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

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

ESM

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))
// Gibt aus: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (Dieses Ergebnis entspricht: [buf2, buf1].)

CJS

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))
// Gibt aus: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (Dieses Ergebnis entspricht: [buf2, buf1].)

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

[Verlauf]

Version	Änderungen
v8.0.0	Die Elemente von list können jetzt Uint8Arrays sein.
v0.7.11	Hinzugefügt in: v0.7.11

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

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

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

Wenn totalLength nicht angegeben ist, wird er aus den Buffer-Instanzen in list berechnet, indem deren Längen addiert werden.

Wenn totalLength angegeben ist, wird er in eine vorzeichenlose Ganzzahl umgewandelt. 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 Platz mit Nullen gefüllt.

ESM

import { Buffer } from 'node:buffer'

// Erstellt einen einzelnen `Buffer` aus einer Liste von drei `Buffer`-Instanzen.

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)
// Gibt aus: 42

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

console.log(bufA)
// Gibt aus: <Buffer 00 00 00 00 ...>
console.log(bufA.length)
// Gibt aus: 42

CJS

const { Buffer } = require('node:buffer')

// Erstellt einen einzelnen `Buffer` aus einer Liste von drei `Buffer`-Instanzen.

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)
// Gibt aus: 42

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

console.log(bufA)
// Gibt aus: <Buffer 00 00 00 00 ...>
console.log(bufA.length)
// Gibt aus: 42

Buffer.concat() kann auch den internen Buffer-Pool verwenden, wie Buffer.allocUnsafe().

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

Hinzugefügt in: v19.8.0, v18.16.0

• view <TypedArray> Das <TypedArray>, das kopiert werden soll.
• 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 zugrundeliegenden 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

Statische Methode: Buffer.from(array)

Hinzugefügt in: v5.10.0

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

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

ESM

import { Buffer } from 'node:buffer'

// Erstellt einen neuen Buffer, der die UTF-8-Bytes der Zeichenkette 'buffer' enthält.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])

CJS

const { Buffer } = require('node:buffer')

// Erstellt einen neuen Buffer, der die UTF-8-Bytes der Zeichenkette 'buffer' enthält.
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])

Wenn array ein Array-ähnliches Objekt ist (d. h. eines mit einer length-Eigenschaft vom Typ number), wird es behandelt, als wäre es ein Array, 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 einem TypedArray zugrunde liegen, verwenden Sie Buffer.copyBytesFrom().

Ein TypeError wird ausgelöst, wenn array kein Array oder ein anderer Typ ist, der für Buffer.from()-Varianten geeignet ist.

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

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

Hinzugefügt in: v5.10.0

• arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> Ein ArrayBuffer, SharedArrayBuffer, beispielsweise die .buffer-Eigenschaft eines TypedArray.
• byteOffset <integer> Index des ersten Bytes, das freigegeben werden soll. Standardwert: 0.
• length <integer> Anzahl der Bytes, die freigegeben werden sollen. Standardwert: arrayBuffer.byteLength - byteOffset.
• Rückgabewert: <Buffer>

Dies erstellt eine Ansicht des ArrayBuffer ohne den zugrunde liegenden Speicher zu kopieren. Wenn beispielsweise ein Verweis auf die .buffer-Eigenschaft einer TypedArray-Instanz übergeben wird, teilt der neu erstellte Buffer denselben zugeordneten Speicher wie der zugrunde liegende ArrayBuffer des TypedArray.

ESM

import { Buffer } from 'node:buffer'

const arr = new Uint16Array(2)

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

// Teilt Speicher mit `arr`.
const buf = Buffer.from(arr.buffer)

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

// Das Ändern des ursprünglichen Uint16Array ändert auch den Buffer.
arr[1] = 6000

console.log(buf)
// Gibt aus: <Buffer 88 13 70 17>

CJS

const { Buffer } = require('node:buffer')

const arr = new Uint16Array(2)

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

// Teilt Speicher mit `arr`.
const buf = Buffer.from(arr.buffer)

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

// Das Ändern des ursprünglichen Uint16Array ändert auch den Buffer.
arr[1] = 6000

console.log(buf)
// Gibt aus: <Buffer 88 13 70 17>

Die optionalen Argumente byteOffset und length geben einen Speicherbereich innerhalb des arrayBuffer an, der vom Buffer gemeinsam genutzt wird.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.length)
// Gibt aus: 2

CJS

const { Buffer } = require('node:buffer')

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

console.log(buf.length)
// Gibt aus: 2

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

Es ist wichtig zu beachten, dass ein unterstützender ArrayBuffer einen Speicherbereich abdecken kann, der über die Grenzen einer TypedArray-Ansicht hinausgeht. Ein neuer Buffer, der mit der buffer-Eigenschaft eines TypedArray erstellt wird, kann über den Bereich des TypedArray hinausgehen:

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

const { Buffer } = require('node:buffer')

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

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

Statische Methode: Buffer.from(buffer)

Hinzugefügt in: v5.10.0

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

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

ESM

import { Buffer } from 'node:buffer'

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

buf1[0] = 0x61

console.log(buf1.toString())
// Gibt aus: auffer
console.log(buf2.toString())
// Gibt aus: buffer

CJS

const { Buffer } = require('node:buffer')

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

buf1[0] = 0x61

console.log(buf1.toString())
// Gibt aus: auffer
console.log(buf2.toString())
// Gibt aus: buffer

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

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

Hinzugefügt in: v8.2.0

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

Für Objekte, deren valueOf()-Funktion einen Wert zurückgibt, der nicht streng gleich object ist, wird Buffer.from(object.valueOf(), offsetOrEncoding, length) zurückgegeben.

ESM

import { Buffer } from 'node:buffer'

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

CJS

const { Buffer } = require('node:buffer')

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

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

ESM

import { Buffer } from 'node:buffer'

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

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

CJS

const { Buffer } = require('node:buffer')

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

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

Ein TypeError wird ausgelöst, wenn object nicht über die genannten Methoden verfügt oder kein anderer für Buffer.from()-Varianten geeigneter Typ ist.

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

Hinzugefügt in: v5.10.0

• string <string> Eine zu kodierende Zeichenkette.
• encoding <string> Die Kodierung von string. Standard: 'utf8'.
• Rückgabewert: <Buffer>

Erstellt einen neuen Buffer, der string enthält. Der Parameter encoding gibt die zu verwendende Zeichenkodierung bei der Konvertierung von string in Bytes an.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf1.toString())
// Gibt aus: this is a tést
console.log(buf2.toString())
// Gibt aus: this is a tést
console.log(buf1.toString('latin1'))
// Gibt aus: this is a tést

CJS

const { Buffer } = require('node:buffer')

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

console.log(buf1.toString())
// Gibt aus: this is a tést
console.log(buf2.toString())
// Gibt aus: this is a tést
console.log(buf1.toString('latin1'))
// Gibt aus: this is a tést

Ein TypeError wird ausgelöst, wenn string keine Zeichenkette oder ein anderer für Buffer.from()-Varianten geeigneter Typ ist.

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

Statische Methode: Buffer.isBuffer(obj)

Hinzugefügt in: v0.1.101

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

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

ESM

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

CJS

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

Statische Methode: Buffer.isEncoding(encoding)

Hinzugefügt in: v0.9.1

• encoding <string> Ein zu überprüfender Zeichenkodierungsname.
• Rückgabewert: <boolean>

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

ESM

import { Buffer } from 'node:buffer'

console.log(Buffer.isEncoding('utf8'))
// Gibt aus: true

console.log(Buffer.isEncoding('hex'))
// Gibt aus: true

console.log(Buffer.isEncoding('utf/8'))
// Gibt aus: false

console.log(Buffer.isEncoding(''))
// Gibt aus: false

CJS

const { Buffer } = require('node:buffer')

console.log(Buffer.isEncoding('utf8'))
// Gibt aus: true

console.log(Buffer.isEncoding('hex'))
// Gibt aus: true

console.log(Buffer.isEncoding('utf/8'))
// Gibt aus: false

console.log(Buffer.isEncoding(''))
// Gibt aus: false

Klassenproperty: Buffer.poolSize

Hinzugefügt in: v0.11.3

• <integer> Standardwert: 8192

Dies ist die Größe (in Bytes) vorab zugewiesener interner Buffer-Instanzen, die für das Pooling verwendet werden. Dieser Wert kann geändert werden.

buf[index]

• index <integer>

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

Dieser Operator wird von Uint8Array geerbt, daher ist sein Verhalten bei Zugriffen außerhalb der Grenzen das gleiche 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 ändert den Buffer nicht, wenn index negativ oder \>= buf.length ist.

ESM

import { Buffer } from 'node:buffer'

// Kopiere eine ASCII-Zeichenkette Byte für Byte in einen `Buffer`.
// (Dies funktioniert nur für reine ASCII-Zeichenketten. Im Allgemeinen sollte man
// `Buffer.from()` verwenden, um diese Konvertierung durchzuführen.)

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'))
// Gibt aus: Node.js

CJS

const { Buffer } = require('node:buffer')

// Kopiere eine ASCII-Zeichenkette Byte für Byte in einen `Buffer`.
// (Dies funktioniert nur für reine ASCII-Zeichenketten. Im Allgemeinen sollte man
// `Buffer.from()` verwenden, um diese Konvertierung durchzuführen.)

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'))
// Gibt aus: Node.js

buf.buffer

• <ArrayBuffer> Das zugrunde liegende ArrayBuffer-Objekt, auf dem dieses Buffer-Objekt basiert.

Dieser ArrayBuffer entspricht nicht unbedingt genau dem ursprünglichen Buffer. Siehe die Hinweise zu buf.byteOffset für Details.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buffer.buffer === arrayBuffer)
// Gibt aus: true

CJS

const { Buffer } = require('node:buffer')

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

console.log(buffer.buffer === arrayBuffer)
// Gibt aus: true

buf.byteOffset

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

Wenn byteOffset in Buffer.from(ArrayBuffer, byteOffset, length) gesetzt wird, oder manchmal, wenn ein Buffer kleiner als Buffer.poolSize zugewiesen wird, beginnt der Buffer nicht bei einem Offset von Null im zugrunde liegenden ArrayBuffer.

Dies kann Probleme verursachen, wenn auf den zugrunde liegenden ArrayBuffer direkt über buf.buffer zugegriffen wird, da andere Teile des ArrayBuffer möglicherweise nichts mit dem Buffer-Objekt selbst zu tun haben.

Ein häufiges Problem beim Erstellen eines TypedArray-Objekts, das seinen Speicher mit einem Buffer teilt, besteht darin, dass in diesem Fall der byteOffset korrekt angegeben werden muss:

ESM

import { Buffer } from 'node:buffer'

// Erstellen Sie einen Buffer, der kleiner als `Buffer.poolSize` ist.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

// Verwenden Sie beim Casten des Node.js Buffers in ein Int8Array den byteOffset,
// um sich nur auf den Teil von `nodeBuffer.buffer` zu beziehen, der den Speicher
// für `nodeBuffer` enthält.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)

CJS

const { Buffer } = require('node:buffer')

// Erstellen Sie einen Buffer, der kleiner als `Buffer.poolSize` ist.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

// Verwenden Sie beim Casten des Node.js Buffers in ein Int8Array den byteOffset,
// um sich nur auf den Teil von `nodeBuffer.buffer` zu beziehen, der den Speicher
// für `nodeBuffer` enthält.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)

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

[Verlauf]

Version	Änderungen
v8.0.0	Der Parameter target kann jetzt ein Uint8Array sein.
v5.11.0	Zusätzliche Parameter zur Angabe von Offsets werden jetzt unterstützt.
v0.11.13	Hinzugefügt in: v0.11.13

• target <Buffer> | <Uint8Array> Ein Buffer oder Uint8Array mit dem buf verglichen wird.
• targetStart <integer> Der Offset innerhalb von target, an dem der Vergleich beginnt. Standardwert: 0.
• targetEnd <integer> Der Offset innerhalb von target, an dem der Vergleich endet (nicht inklusiv). Standardwert: target.length.
• sourceStart <integer> Der Offset innerhalb von buf, an dem der Vergleich beginnt. Standardwert: 0.
• sourceEnd <integer> Der Offset innerhalb von buf, an dem der Vergleich endet (nicht inklusiv). Standardwert: buf.length.
• Rückgabewert: <integer>

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

• 0 wird zurückgegeben, wenn target gleich buf ist.
• 1 wird zurückgegeben, wenn target bei der Sortierung vor buf kommen sollte.
• -1 wird zurückgegeben, wenn target bei der Sortierung nach buf kommen sollte.

ESM

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))
// Gibt aus: 0
console.log(buf1.compare(buf2))
// Gibt aus: -1
console.log(buf1.compare(buf3))
// Gibt aus: -1
console.log(buf2.compare(buf1))
// Gibt aus: 1
console.log(buf2.compare(buf3))
// Gibt aus: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// Gibt aus: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (Dieses Ergebnis entspricht: [buf1, buf3, buf2].)

CJS

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))
// Gibt aus: 0
console.log(buf1.compare(buf2))
// Gibt aus: -1
console.log(buf1.compare(buf3))
// Gibt aus: -1
console.log(buf2.compare(buf1))
// Gibt aus: 1
console.log(buf2.compare(buf3))
// Gibt aus: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// Gibt aus: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (Dieses Ergebnis entspricht: [buf1, buf3, buf2].)

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

ESM

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))
// Gibt aus: 0
console.log(buf1.compare(buf2, 0, 6, 4))
// Gibt aus: -1
console.log(buf1.compare(buf2, 5, 6, 5))
// Gibt aus: 1

CJS

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))
// Gibt aus: 0
console.log(buf1.compare(buf2, 0, 6, 4))
// Gibt aus: -1
console.log(buf1.compare(buf2, 5, 6, 5))
// Gibt aus: 1

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

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

Hinzugefügt in: v0.1.90

• target <Buffer> | <Uint8Array> Ein Buffer oder Uint8Array zum Kopieren hinein.
• targetStart <integer> Der Offset innerhalb von target, an dem mit dem Schreiben begonnen werden soll. Standard: 0.
• sourceStart <integer> Der Offset innerhalb von buf, von dem aus mit dem Kopieren begonnen werden soll. Standard: 0.
• sourceEnd <integer> Der Offset innerhalb von buf, an dem das Kopieren beendet werden soll (nicht inklusiv). Standard: buf.length.
• Gibt zurück: <integer> Die Anzahl der kopierten Bytes.

Kopiert Daten aus einem Bereich von buf in einen Bereich in target, selbst wenn der target-Speicherbereich mit buf überlappt.

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

ESM

import { Buffer } from 'node:buffer'

// Erstellt zwei `Buffer`-Instanzen.
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')

for (let i = 0; i < 26; i++) {
  // 97 ist der dezimale ASCII-Wert für 'a'.
  buf1[i] = i + 97
}

// Kopiert `buf1` Bytes 16 bis 19 in `buf2`, beginnend bei Byte 8 von `buf2`.
buf1.copy(buf2, 8, 16, 20)
// Dies ist äquivalent zu:
// buf2.set(buf1.subarray(16, 20), 8);

console.log(buf2.toString('ascii', 0, 25))
// Gibt aus: !!!!!!!!qrst!!!!!!!!!!!!!

CJS

const { Buffer } = require('node:buffer')

// Erstellt zwei `Buffer`-Instanzen.
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')

for (let i = 0; i < 26; i++) {
  // 97 ist der dezimale ASCII-Wert für 'a'.
  buf1[i] = i + 97
}

// Kopiert `buf1` Bytes 16 bis 19 in `buf2`, beginnend bei Byte 8 von `buf2`.
buf1.copy(buf2, 8, 16, 20)
// Dies ist äquivalent zu:
// buf2.set(buf1.subarray(16, 20), 8);

console.log(buf2.toString('ascii', 0, 25))
// Gibt aus: !!!!!!!!qrst!!!!!!!!!!!!!

ESM

import { Buffer } from 'node:buffer'

// Erstellt einen `Buffer` und kopiert Daten von einem Bereich in einen überlappenden Bereich
// innerhalb desselben `Buffer`.

const buf = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 ist der dezimale ASCII-Wert für 'a'.
  buf[i] = i + 97
}

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

console.log(buf.toString())
// Gibt aus: efghijghijklmnopqrstuvwxyz

CJS

const { Buffer } = require('node:buffer')

// Erstellt einen `Buffer` und kopiert Daten von einem Bereich in einen überlappenden Bereich
// innerhalb desselben `Buffer`.

const buf = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 ist der dezimale ASCII-Wert für 'a'.
  buf[i] = i + 97
}

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

console.log(buf.toString())
// Gibt aus: efghijghijklmnopqrstuvwxyz

buf.entries()

Hinzugefügt in: v1.1.0

• Gibt zurück: <Iterator>

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

ESM

import { Buffer } from 'node:buffer'

// Gibt den gesamten Inhalt eines `Buffer` aus.

const buf = Buffer.from('buffer')

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

CJS

const { Buffer } = require('node:buffer')

// Gibt den gesamten Inhalt eines `Buffer` aus.

const buf = Buffer.from('buffer')

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

buf.equals(otherBuffer)

[Verlauf]

Version	Änderungen
v8.0.0	Die Argumente können jetzt Uint8Arrays sein.
v0.11.13	Hinzugefügt in: v0.11.13

• otherBuffer <Buffer> | <Uint8Array> Ein Buffer oder Uint8Array mit dem buf verglichen werden soll.
• Gibt zurück: <boolean>

Gibt true zurück, wenn sowohl buf als auch otherBuffer exakt die gleichen Bytes haben, andernfalls false. Äquivalent zu buf.compare(otherBuffer) === 0.

ESM

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))
// Gibt aus: true
console.log(buf1.equals(buf3))
// Gibt aus: false

CJS

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))
// Gibt aus: true
console.log(buf1.equals(buf3))
// Gibt aus: false

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

[Verlauf]

Version	Änderungen
v11.0.0	Wirft ERR_OUT_OF_RANGE statt ERR_INDEX_OUT_OF_RANGE.
v10.0.0	Negative end-Werte werfen einen ERR_INDEX_OUT_OF_RANGE-Fehler.
v10.0.0	Der Versuch, einen Puffer ungleich null mit einem Puffer der Länge null zu füllen, löst eine Ausnahme aus.
v10.0.0	Die Angabe einer ungültigen Zeichenkette für value löst eine Ausnahme aus.
v5.7.0	Der Parameter encoding wird jetzt unterstützt.
v0.5.0	Hinzugefügt in: v0.5.0

• value <string> | <Buffer> | <Uint8Array> | <integer> Der Wert, mit dem buf gefüllt werden soll. Ein leerer Wert (String, Uint8Array, Buffer) wird in 0 umgewandelt.
• 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 beendet werden soll (nicht inklusive). Standard: buf.length.
• encoding <string> Die Codierung für value, wenn value eine Zeichenkette ist. Standard: 'utf8'.
• Rückgabewert: <Buffer> Ein Verweis auf buf.

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

ESM

import { Buffer } from 'node:buffer'

// Füllt einen `Buffer` mit dem ASCII-Zeichen 'h'.

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

console.log(b.toString())
// Gibt aus: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

// Füllt einen Buffer mit einem leeren String
const c = Buffer.allocUnsafe(5).fill('')

console.log(c.fill(''))
// Gibt aus: <Buffer 00 00 00 00 00>

CJS

const { Buffer } = require('node:buffer')

// Füllt einen `Buffer` mit dem ASCII-Zeichen 'h'.

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

console.log(b.toString())
// Gibt aus: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

// Füllt einen Buffer mit einem leeren String
const c = Buffer.allocUnsafe(5).fill('')

console.log(c.fill(''))
// Gibt aus: <Buffer 00 00 00 00 00>

value wird in einen uint32-Wert umgewandelt, wenn es keine Zeichenkette, kein Buffer oder keine ganze Zahl ist. Wenn die resultierende ganze Zahl größer als 255 (dezimal) ist, wird buf mit value & 255 gefüllt.

Wenn der letzte Schreibvorgang einer fill()-Operation auf ein mehrbyteiges Zeichen fällt, werden nur die Bytes dieses Zeichens, die in buf passen, geschrieben:

ESM

import { Buffer } from 'node:buffer'

// Füllt einen `Buffer` mit einem Zeichen, das in UTF-8 zwei Bytes belegt.

console.log(Buffer.allocUnsafe(5).fill('\u0222'))
// Gibt aus: <Buffer c8 a2 c8 a2 c8>

CJS

const { Buffer } = require('node:buffer')

// Füllt einen `Buffer` mit einem Zeichen, das in UTF-8 zwei Bytes belegt.

console.log(Buffer.allocUnsafe(5).fill('\u0222'))
// Gibt aus: <Buffer c8 a2 c8 a2 c8>

Wenn value ungültige Zeichen enthält, wird es abgeschnitten; wenn keine gültigen Fülldaten mehr vorhanden sind, wird eine Ausnahme ausgelöst:

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(5)

console.log(buf.fill('a'))
// Gibt aus: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// Gibt aus: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// Löst eine Ausnahme aus.

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(5)

console.log(buf.fill('a'))
// Gibt aus: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// Gibt aus: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// Löst eine Ausnahme aus.

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

Hinzugefügt in: v5.3.0

• value <string> | <Buffer> | <Uint8Array> | <integer> Wonach gesucht werden soll.
• byteOffset <integer> Wo die Suche in buf beginnen soll. Bei negativen Werten wird der Offset vom Ende von buf berechnet. Standard: 0.
• encoding <string> Wenn value eine Zeichenkette ist, ist dies deren Codierung. Standard: 'utf8'.
• Rückgabewert: <boolean> true, wenn value in buf gefunden wurde, andernfalls false.

Äquivalent zu buf.indexOf() !== -1.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.includes('this'))
// Gibt aus: true
console.log(buf.includes('is'))
// Gibt aus: true
console.log(buf.includes(Buffer.from('a buffer')))
// Gibt aus: true
console.log(buf.includes(97))
// Gibt aus: true (97 ist der dezimale ASCII-Wert für 'a')
console.log(buf.includes(Buffer.from('a buffer example')))
// Gibt aus: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// Gibt aus: true
console.log(buf.includes('this', 4))
// Gibt aus: false

CJS

const { Buffer } = require('node:buffer')

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

console.log(buf.includes('this'))
// Gibt aus: true
console.log(buf.includes('is'))
// Gibt aus: true
console.log(buf.includes(Buffer.from('a buffer')))
// Gibt aus: true
console.log(buf.includes(97))
// Gibt aus: true (97 ist der dezimale ASCII-Wert für 'a')
console.log(buf.includes(Buffer.from('a buffer example')))
// Gibt aus: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// Gibt aus: true
console.log(buf.includes('this', 4))
// Gibt aus: false

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

[Verlauf]

Version	Änderungen
v8.0.0	value kann nun ein Uint8Array sein.
v5.7.0, v4.4.0	Wenn encoding übergeben wird, ist der Parameter byteOffset nicht mehr erforderlich.
v1.5.0	Hinzugefügt in: v1.5.0

• value <string> | <Buffer> | <Uint8Array> | <integer> Was gesucht werden soll.
• byteOffset <integer> Wo die Suche in buf beginnen soll. Bei negativen Werten wird der Offset vom Ende von buf berechnet. Standard: 0.
• encoding <string> Wenn value eine Zeichenkette ist, ist dies die Codierung, die verwendet wird, um die binäre Darstellung der Zeichenkette zu bestimmen, nach der in buf gesucht wird. Standard: 'utf8'.
• Rückgabewert: <integer> Der Index des ersten Auftretens von value in buf oder -1, wenn buf value nicht enthält.

Wenn value ist:

• eine Zeichenkette, wird value gemäß der Zeichencodierung 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 vorzeichenloser 8-Bit-Ganzzahlwert zwischen 0 und 255 interpretiert.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.indexOf('this'))
// Gibt aus: 0
console.log(buf.indexOf('is'))
// Gibt aus: 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// Gibt aus: 8
console.log(buf.indexOf(97))
// Gibt aus: 8 (97 ist der dezimale ASCII-Wert für 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')))
// Gibt aus: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// Gibt aus: 8

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

console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'))
// Gibt aus: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'))
// Gibt aus: 6

CJS

const { Buffer } = require('node:buffer')

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

console.log(buf.indexOf('this'))
// Gibt aus: 0
console.log(buf.indexOf('is'))
// Gibt aus: 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// Gibt aus: 8
console.log(buf.indexOf(97))
// Gibt aus: 8 (97 ist der dezimale ASCII-Wert für 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')))
// Gibt aus: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// Gibt aus: 8

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

console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'))
// Gibt aus: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'))
// Gibt aus: 6

Wenn value keine Zeichenkette, Zahl oder Buffer ist, löst diese Methode einen TypeError aus. Wenn value eine Zahl ist, wird sie in einen gültigen Bytewert umgewandelt, eine Ganzzahl zwischen 0 und 255.

Wenn byteOffset keine Zahl ist, wird sie in eine Zahl umgewandelt. Wenn das Ergebnis der Umwandlung NaN oder 0 ist, wird der gesamte Buffer durchsucht. Dieses Verhalten entspricht String.prototype.indexOf().

ESM

import { Buffer } from 'node:buffer'

const b = Buffer.from('abcdef')

// Übergabe eines Wertes, der eine Zahl, aber kein gültiges Byte ist.
// Gibt aus: 2, entspricht der Suche nach 99 oder 'c'.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))

// Übergabe eines byteOffset, das zu NaN oder 0 umgewandelt wird.
// Gibt aus: 1, der gesamte Buffer wird durchsucht.
console.log(b.indexOf('b', undefined))
console.log(b.indexOf('b', {}))
console.log(b.indexOf('b', null))
console.log(b.indexOf('b', []))

CJS

const { Buffer } = require('node:buffer')

const b = Buffer.from('abcdef')

// Übergabe eines Wertes, der eine Zahl, aber kein gültiges Byte ist.
// Gibt aus: 2, entspricht der Suche nach 99 oder 'c'.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))

// Übergabe eines byteOffset, das zu NaN oder 0 umgewandelt wird.
// Gibt aus: 1, der gesamte Buffer wird durchsucht.
console.log(b.indexOf('b', undefined))
console.log(b.indexOf('b', {}))
console.log(b.indexOf('b', null))
console.log(b.indexOf('b', []))

Wenn value eine leere Zeichenkette oder ein leerer Buffer ist und byteOffset kleiner als buf.length ist, wird byteOffset zurückgegeben. Wenn value leer ist und byteOffset mindestens buf.length beträgt, wird buf.length zurückgegeben.

buf.keys()

Hinzugefügt in: v1.1.0

• Gibt zurück: <Iterator>

Erstellt und gibt einen Iterator der Schlüssel (Indizes) von buf zurück.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

for (const key of buf.keys()) {
  console.log(key)
}
// Gibt aus:
//   0
//   1
//   2
//   3
//   4
//   5

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from('buffer')

for (const key of buf.keys()) {
  console.log(key)
}
// Gibt aus:
//   0
//   1
//   2
//   3
//   4
//   5

buf.lastIndexOf(value[, byteOffset][, encoding])

[Verlauf]

Version	Änderungen
v8.0.0	value kann jetzt ein Uint8Array sein.
v6.0.0	Hinzugefügt in: v6.0.0

• value <string> | <Buffer> | <Uint8Array> | <integer> Was gesucht werden soll.
• byteOffset <integer> Wo die Suche in buf beginnen soll. Wenn negativ, wird der Offset vom Ende von buf berechnet. Standard: buf.length - 1.
• encoding <string> Wenn value eine Zeichenkette ist, ist dies die Codierung, die verwendet wird, um die binäre Darstellung der Zeichenkette zu bestimmen, nach der in buf gesucht wird. Standard: 'utf8'.
• Gibt zurück: <integer> Der Index des letzten Auftretens von value in buf oder -1, wenn buf value nicht enthält.

Identisch mit buf.indexOf(), außer dass das letzte Auftreten von value gefunden wird, anstatt das erste.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.lastIndexOf('this'))
// Gibt aus: 0
console.log(buf.lastIndexOf('buffer'))
// Gibt aus: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')))
// Gibt aus: 17
console.log(buf.lastIndexOf(97))
// Gibt aus: 15 (97 ist der dezimale ASCII-Wert für 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')))
// Gibt aus: -1
console.log(buf.lastIndexOf('buffer', 5))
// Gibt aus: 5
console.log(buf.lastIndexOf('buffer', 4))
// Gibt aus: -1

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

console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'))
// Gibt aus: 6
console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'))
// Gibt aus: 4

CJS

const { Buffer } = require('node:buffer')

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

console.log(buf.lastIndexOf('this'))
// Gibt aus: 0
console.log(buf.lastIndexOf('buffer'))
// Gibt aus: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')))
// Gibt aus: 17
console.log(buf.lastIndexOf(97))
// Gibt aus: 15 (97 ist der dezimale ASCII-Wert für 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')))
// Gibt aus: -1
console.log(buf.lastIndexOf('buffer', 5))
// Gibt aus: 5
console.log(buf.lastIndexOf('buffer', 4))
// Gibt aus: -1

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

console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'))
// Gibt aus: 6
console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'))
// Gibt aus: 4

Wenn value keine Zeichenkette, Zahl oder Buffer ist, löst diese Methode einen TypeError aus. Wenn value eine Zahl ist, wird sie in einen gültigen Bytewert umgewandelt, eine ganze Zahl zwischen 0 und 255.

Wenn byteOffset keine Zahl ist, wird sie in eine Zahl umgewandelt. Argumente, die zu NaN konvertiert werden, wie {} oder undefined, durchsuchen den gesamten Puffer. Dieses Verhalten entspricht String.prototype.lastIndexOf().

ESM

import { Buffer } from 'node:buffer'

const b = Buffer.from('abcdef')

// Übergabe eines Wertes, der eine Zahl ist, aber kein gültiges Byte.
// Gibt aus: 2, entspricht der Suche nach 99 oder 'c'.
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))

// Übergabe eines byteOffset, der zu NaN konvertiert wird.
// Gibt aus: 1, durchsucht den gesamten Puffer.
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))

// Übergabe eines byteOffset, der zu 0 konvertiert wird.
// Gibt aus: -1, entspricht der Übergabe von 0.
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))

CJS

const { Buffer } = require('node:buffer')

const b = Buffer.from('abcdef')

// Übergabe eines Wertes, der eine Zahl ist, aber kein gültiges Byte.
// Gibt aus: 2, entspricht der Suche nach 99 oder 'c'.
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))

// Übergabe eines byteOffset, der zu NaN konvertiert wird.
// Gibt aus: 1, durchsucht den gesamten Puffer.
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))

// Übergabe eines byteOffset, der zu 0 konvertiert wird.
// Gibt aus: -1, entspricht der Übergabe von 0.
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))

Wenn value eine leere Zeichenkette oder ein leerer Buffer ist, wird byteOffset zurückgegeben.

buf.length

Hinzugefügt in: v0.1.90

• <integer>

Gibt die Anzahl der Bytes in buf zurück.

ESM

import { Buffer } from 'node:buffer'

// Erstellt einen `Buffer` und schreibt eine kürzere Zeichenkette mit UTF-8 hinein.

const buf = Buffer.alloc(1234)

console.log(buf.length)
// Gibt aus: 1234

buf.write('some string', 0, 'utf8')

console.log(buf.length)
// Gibt aus: 1234

CJS

const { Buffer } = require('node:buffer')

// Erstellt einen `Buffer` und schreibt eine kürzere Zeichenkette mit UTF-8 hinein.

const buf = Buffer.alloc(1234)

console.log(buf.length)
// Gibt aus: 1234

buf.write('some string', 0, 'utf8')

console.log(buf.length)
// Gibt aus: 1234

buf.parent

Seit v8.0.0 veraltet

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet: Verwenden Sie stattdessen buf.buffer.

Die Eigenschaft buf.parent ist ein veraltetes Alias für buf.buffer.

buf.readBigInt64BE([offset])

Hinzugefügt in: v12.0.0, v10.20.0

• offset <integer> Anzahl der Bytes, die übersprungen werden sollen, bevor mit dem Lesen begonnen wird. Muss erfüllen: 0 \<= offset \<= buf.length - 8. Standard: 0.
• Rückgabewert: <bigint>

Liest eine vorzeichenbehaftete, big-endian 64-Bit-Ganzzahl aus buf an der angegebenen offset.

Aus einem Buffer gelesene Ganzzahlen werden als vorzeichenbehaftete Zweierkomplement-Werte interpretiert.

buf.readBigInt64LE([offset])

Hinzugefügt in: v12.0.0, v10.20.0

• offset <integer> Anzahl der Bytes, die übersprungen werden sollen, bevor mit dem Lesen begonnen wird. Muss erfüllen: 0 \<= offset \<= buf.length - 8. Standard: 0.
• Rückgabewert: <bigint>

Liest eine vorzeichenbehaftete, little-endian 64-Bit-Ganzzahl aus buf an der angegebenen offset.

Aus einem Buffer gelesene Ganzzahlen werden als vorzeichenbehaftete Zweierkomplement-Werte interpretiert.

buf.readBigUInt64BE([offset])

[Verlauf]

Version	Änderungen
v14.10.0, v12.19.0	Diese Funktion ist auch als buf.readBigUint64BE() verfügbar.
v12.0.0, v10.20.0	Hinzugefügt in: v12.0.0, v10.20.0

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss erfüllen: 0 \<= offset \<= buf.length - 8. Standard: 0.
• Rückgabewert: <bigint>

Liest eine vorzeichenlose, big-endian 64-Bit-Ganzzahl aus buf an der angegebenen offset.

Diese Funktion ist auch unter dem Alias readBigUint64BE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])

console.log(buf.readBigUInt64BE(0))
// Gibt aus: 4294967295n

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])

console.log(buf.readBigUInt64BE(0))
// Gibt aus: 4294967295n

buf.readBigUInt64LE([offset])

[Verlauf]

Version	Änderungen
v14.10.0, v12.19.0	Diese Funktion ist auch als buf.readBigUint64LE() verfügbar.
v12.0.0, v10.20.0	Hinzugefügt in: v12.0.0, v10.20.0

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss erfüllen: 0 \<= offset \<= buf.length - 8. Standard: 0.
• Rückgabewert: <bigint>

Liest eine vorzeichenlose, little-endian 64-Bit-Ganzzahl aus buf an der angegebenen offset.

Diese Funktion ist auch unter dem Alias readBigUint64LE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])

console.log(buf.readBigUInt64LE(0))
// Gibt aus: 18446744069414584320n

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])

console.log(buf.readBigUInt64LE(0))
// Gibt aus: 18446744069414584320n

buf.readDoubleBE([offset])

[History]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.11.15	Hinzugefügt in: v0.11.15

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 8 erfüllen. Standard: 0.
• Rückgabewert: <number>

Liest eine 64-Bit-Double-Zahl mit Big-Endian-Byteordnung aus buf an der angegebenen offset Stelle.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])

console.log(buf.readDoubleBE(0))
// Gibt aus: 8.20788039913184e-304

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])

console.log(buf.readDoubleBE(0))
// Gibt aus: 8.20788039913184e-304

buf.readDoubleLE([offset])

[History]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.11.15	Hinzugefügt in: v0.11.15

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 8 erfüllen. Standard: 0.
• Rückgabewert: <number>

Liest eine 64-Bit-Double-Zahl mit Little-Endian-Byteordnung aus buf an der angegebenen offset Stelle.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])

console.log(buf.readDoubleLE(0))
// Gibt aus: 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// Wirft ERR_OUT_OF_RANGE.

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])

console.log(buf.readDoubleLE(0))
// Gibt aus: 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// Wirft ERR_OUT_OF_RANGE.

buf.readFloatBE([offset])

[Verlauf]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.11.15	Hinzugefügt in: v0.11.15

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standardwert: 0.
• Rückgabewert: <number>

Liest einen 32-Bit Big-Endian-Float aus buf an der angegebenen offset Stelle.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readFloatBE(0))
// Gibt aus: 2.387939260590663e-38

CJS

const { Buffer } = require('node:buffer')

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

console.log(buf.readFloatBE(0))
// Gibt aus: 2.387939260590663e-38

buf.readFloatLE([offset])

[Verlauf]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.11.15	Hinzugefügt in: v0.11.15

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standardwert: 0.
• Rückgabewert: <number>

Liest einen 32-Bit Little-Endian-Float aus buf an der angegebenen offset Stelle.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readFloatLE(0))
// Gibt aus: 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// Wirft ERR_OUT_OF_RANGE.

CJS

const { Buffer } = require('node:buffer')

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

console.log(buf.readFloatLE(0))
// Gibt aus: 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// Wirft ERR_OUT_OF_RANGE.

buf.readInt8([offset])

[Versionsgeschichte]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.0	Hinzugefügt in: v0.5.0

• offset <integer> Anzahl der zu überspringenden Bytes vor Beginn des Lesens. Muss 0 \<= offset \<= buf.length - 1 erfüllen. Standard: 0.
• Rückgabewert: <integer>

Liest eine vorzeichenbehaftete 8-Bit-Ganzzahl aus buf an der angegebenen offset.

Aus einem Buffer gelesene Ganzzahlen werden als vorzeichenbehaftete Zweierkomplementwerte interpretiert.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([-1, 5])

console.log(buf.readInt8(0))
// Gibt aus: -1
console.log(buf.readInt8(1))
// Gibt aus: 5
console.log(buf.readInt8(2))
// Wirft ERR_OUT_OF_RANGE.

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([-1, 5])

console.log(buf.readInt8(0))
// Gibt aus: -1
console.log(buf.readInt8(1))
// Gibt aus: 5
console.log(buf.readInt8(2))
// Wirft ERR_OUT_OF_RANGE.

buf.readInt16BE([offset])

[Versionsgeschichte]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• offset <integer> Anzahl der zu überspringenden Bytes vor Beginn des Lesens. Muss 0 \<= offset \<= buf.length - 2 erfüllen. Standard: 0.
• Rückgabewert: <integer>

Liest eine vorzeichenbehaftete, Big-Endian 16-Bit-Ganzzahl aus buf an der angegebenen offset.

Aus einem Buffer gelesene Ganzzahlen werden als vorzeichenbehaftete Zweierkomplementwerte interpretiert.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0, 5])

console.log(buf.readInt16BE(0))
// Gibt aus: 5

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0, 5])

console.log(buf.readInt16BE(0))
// Gibt aus: 5

buf.readInt16LE([offset])

[History]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 2 erfüllen. Standardwert: 0.
• Rückgabewert: <integer>

Liest eine vorzeichenbehaftete, little-endian 16-Bit-Ganzzahl aus buf an der angegebenen offset.

Aus einem Buffer gelesene Ganzzahlen werden als vorzeichenbehaftete Zweierkomplement-Werte interpretiert.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0, 5])

console.log(buf.readInt16LE(0))
// Gibt aus: 1280
console.log(buf.readInt16LE(1))
// Wirft ERR_OUT_OF_RANGE.

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0, 5])

console.log(buf.readInt16LE(0))
// Gibt aus: 1280
console.log(buf.readInt16LE(1))
// Wirft ERR_OUT_OF_RANGE.

buf.readInt32BE([offset])

[History]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standardwert: 0.
• Rückgabewert: <integer>

Liest eine vorzeichenbehaftete, big-endian 32-Bit-Ganzzahl aus buf an der angegebenen offset.

Aus einem Buffer gelesene Ganzzahlen werden als vorzeichenbehaftete Zweierkomplement-Werte interpretiert.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0, 0, 0, 5])

console.log(buf.readInt32BE(0))
// Gibt aus: 5

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0, 0, 0, 5])

console.log(buf.readInt32BE(0))
// Gibt aus: 5

buf.readInt32LE([offset])

[Historie]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standard: 0.
• Rückgabewert: <integer>

Liest eine vorzeichenbehaftete, little-endian 32-Bit-Ganzzahl von buf an der angegebenen offset.

Von einem Buffer gelesene Ganzzahlen werden als vorzeichenbehaftete Zweierkomplementwerte interpretiert.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0, 0, 0, 5])

console.log(buf.readInt32LE(0))
// Gibt aus: 83886080
console.log(buf.readInt32LE(1))
// Wirft ERR_OUT_OF_RANGE.

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0, 0, 0, 5])

console.log(buf.readInt32LE(0))
// Gibt aus: 83886080
console.log(buf.readInt32LE(1))
// Wirft ERR_OUT_OF_RANGE.

buf.readIntBE(offset, byteLength)

[Historie]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets und byteLength zu uint32 mehr.
v0.11.15	Hinzugefügt in: v0.11.15

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - byteLength erfüllen.
• byteLength <integer> Anzahl der zu lesenden Bytes. Muss 0 \< byteLength \<= 6 erfüllen.
• Rückgabewert: <integer>

Liest byteLength Anzahl von Bytes von buf an der angegebenen offset und interpretiert das Ergebnis als big-endian, vorzeichenbehafteter Zweierkomplementwert, der bis zu 48 Bit Genauigkeit unterstützt.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readIntBE(0, 6).toString(16))
// Gibt aus: 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16))
// Wirft ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16))
// Wirft ERR_OUT_OF_RANGE.

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readIntBE(0, 6).toString(16))
// Gibt aus: 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16))
// Wirft ERR_OUT_OF_RANGE.
console.log(buf.readIntBE(1, 0).toString(16))
// Wirft ERR_OUT_OF_RANGE.

buf.readIntLE(offset, byteLength)

[Historie]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung von offset und byteLength mehr zu uint32.
v0.11.15	Hinzugefügt in: v0.11.15

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - byteLength erfüllen.
• byteLength <integer> Anzahl der zu lesenden Bytes. Muss 0 \< byteLength \<= 6 erfüllen.
• Rückgabewert: <integer>

Liest byteLength viele Bytes aus buf an der angegebenen offset Stelle und interpretiert das Ergebnis als little-endian, Zweierkomplement-Vorzeichenwert, der bis zu 48 Bit Genauigkeit unterstützt.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readIntLE(0, 6).toString(16))
// Gibt aus: -546f87a9cbee

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readIntLE(0, 6).toString(16))
// Gibt aus: -546f87a9cbee

buf.readUInt8([offset])

[Historie]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.readUint8() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.0	Hinzugefügt in: v0.5.0

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 1 erfüllen. Standardwert: 0.
• Rückgabewert: <integer>

Liest eine vorzeichenlose 8-Bit-Ganzzahl aus buf an der angegebenen offset Stelle.

Diese Funktion ist auch unter dem Alias readUint8 verfügbar.

ESM

import { Buffer } from 'node:buffer'

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

console.log(buf.readUInt8(0))
// Gibt aus: 1
console.log(buf.readUInt8(1))
// Gibt aus: 254
console.log(buf.readUInt8(2))
// Wirft ERR_OUT_OF_RANGE.

CJS

const { Buffer } = require('node:buffer')

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

console.log(buf.readUInt8(0))
// Gibt aus: 1
console.log(buf.readUInt8(1))
// Gibt aus: 254
console.log(buf.readUInt8(2))
// Wirft ERR_OUT_OF_RANGE.

buf.readUInt16BE([offset])

[Versionsgeschichte]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.readUint16BE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 2 erfüllen. Standard: 0.
• Rückgabewert: <integer>

Liest eine vorzeichenlose, big-endian 16-Bit-Ganzzahl aus buf an der angegebenen offset.

Diese Funktion ist auch unter dem Alias readUint16BE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56])

console.log(buf.readUInt16BE(0).toString(16))
// Gibt aus: 1234
console.log(buf.readUInt16BE(1).toString(16))
// Gibt aus: 3456

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56])

console.log(buf.readUInt16BE(0).toString(16))
// Gibt aus: 1234
console.log(buf.readUInt16BE(1).toString(16))
// Gibt aus: 3456

buf.readUInt16LE([offset])

[Versionsgeschichte]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.readUint16LE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 2 erfüllen. Standard: 0.
• Rückgabewert: <integer>

Liest eine vorzeichenlose, little-endian 16-Bit-Ganzzahl aus buf an der angegebenen offset.

Diese Funktion ist auch unter dem Alias readUint16LE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56])

console.log(buf.readUInt16LE(0).toString(16))
// Gibt aus: 3412
console.log(buf.readUInt16LE(1).toString(16))
// Gibt aus: 5634
console.log(buf.readUInt16LE(2).toString(16))
// Wirft ERR_OUT_OF_RANGE.

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56])

console.log(buf.readUInt16LE(0).toString(16))
// Gibt aus: 3412
console.log(buf.readUInt16LE(1).toString(16))
// Gibt aus: 5634
console.log(buf.readUInt16LE(2).toString(16))
// Wirft ERR_OUT_OF_RANGE.

buf.readUInt32BE([offset])

[Versionsgeschichte]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.readUint32BE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standard: 0.
• Rückgabewert: <integer>

Liest eine vorzeichenlose, Big-Endian 32-Bit-Ganzzahl aus buf an der angegebenen offset.

Diese Funktion ist auch unter dem Alias readUint32BE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])

console.log(buf.readUInt32BE(0).toString(16))
// Gibt aus: 12345678

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])

console.log(buf.readUInt32BE(0).toString(16))
// Gibt aus: 12345678

buf.readUInt32LE([offset])

[Versionsgeschichte]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.readUint32LE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• offset <integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standard: 0.
• Rückgabewert: <integer>

Liest eine vorzeichenlose, Little-Endian 32-Bit-Ganzzahl aus buf an der angegebenen offset.

Diese Funktion ist auch unter dem Alias readUint32LE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])

console.log(buf.readUInt32LE(0).toString(16))
// Gibt aus: 78563412
console.log(buf.readUInt32LE(1).toString(16))
// Wirft ERR_OUT_OF_RANGE.

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])

console.log(buf.readUInt32LE(0).toString(16))
// Gibt aus: 78563412
console.log(buf.readUInt32LE(1).toString(16))
// Wirft ERR_OUT_OF_RANGE.

buf.readUIntBE(offset, byteLength)

[Versionsgeschichte]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.readUintBE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung von offset und byteLength mehr zu uint32.
v0.11.15	Hinzugefügt in: v0.11.15

• offset <Integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - byteLength erfüllen.
• byteLength <Integer> Anzahl der zu lesenden Bytes. Muss 0 \< byteLength \<= 6 erfüllen.
• Rückgabewert: <Integer>

Liest byteLength Bytes aus buf an der angegebenen offset Stelle und interpretiert das Ergebnis als vorzeichenlose Big-Endian-Ganzzahl mit bis zu 48 Bit Genauigkeit.

Diese Funktion ist auch unter dem Alias readUintBE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readUIntBE(0, 6).toString(16))
// Gibt aus: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16))
// Wirft ERR_OUT_OF_RANGE.

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readUIntBE(0, 6).toString(16))
// Gibt aus: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16))
// Wirft ERR_OUT_OF_RANGE.

buf.readUIntLE(offset, byteLength)

[Versionsgeschichte]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.readUintLE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung von offset und byteLength mehr zu uint32.
v0.11.15	Hinzugefügt in: v0.11.15

• offset <Integer> Anzahl der Bytes, die vor Beginn des Lesens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - byteLength erfüllen.
• byteLength <Integer> Anzahl der zu lesenden Bytes. Muss 0 \< byteLength \<= 6 erfüllen.
• Rückgabewert: <Integer>

Liest byteLength Bytes aus buf an der angegebenen offset Stelle und interpretiert das Ergebnis als vorzeichenlose Little-Endian-Ganzzahl mit bis zu 48 Bit Genauigkeit.

Diese Funktion ist auch unter dem Alias readUintLE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readUIntLE(0, 6).toString(16))
// Gibt aus: ab9078563412

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])

console.log(buf.readUIntLE(0, 6).toString(16))
// Gibt aus: ab9078563412

buf.subarray([start[, end]])

Hinzugefügt in: v3.0.0

• start <integer> Wo der neue Buffer beginnt. Standardwert: 0.
• end <integer> Wo der neue Buffer endet (nicht inklusiv). Standardwert: buf.length.
• Rückgabewert: <Buffer>

Gibt einen neuen Buffer zurück, der auf denselben Speicher wie das Original verweist, aber durch die start- und end-Indizes verschoben und zugeschnitten ist.

Die Angabe von end größer als buf.length liefert das gleiche Ergebnis wie end gleich buf.length.

Diese Methode wird von TypedArray.prototype.subarray() geerbt.

Das Ändern des neuen Buffer-Abschnitts ändert den Speicher im ursprünglichen Buffer, da sich der zugewiesene Speicher der beiden Objekte überschneidet.

ESM

import { Buffer } from 'node:buffer'

// Erstellt einen `Buffer` mit dem ASCII-Alphabet, nimmt einen Abschnitt und ändert ein Byte
// aus dem ursprünglichen `Buffer`.

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 ist der dezimale ASCII-Wert für 'a'.
  buf1[i] = i + 97
}

const buf2 = buf1.subarray(0, 3)

console.log(buf2.toString('ascii', 0, buf2.length))
// Gibt aus: abc

buf1[0] = 33

console.log(buf2.toString('ascii', 0, buf2.length))
// Gibt aus: !bc

CJS

const { Buffer } = require('node:buffer')

// Erstellt einen `Buffer` mit dem ASCII-Alphabet, nimmt einen Abschnitt und ändert ein Byte
// aus dem ursprünglichen `Buffer`.

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 ist der dezimale ASCII-Wert für 'a'.
  buf1[i] = i + 97
}

const buf2 = buf1.subarray(0, 3)

console.log(buf2.toString('ascii', 0, buf2.length))
// Gibt aus: abc

buf1[0] = 33

console.log(buf2.toString('ascii', 0, buf2.length))
// Gibt aus: !bc

Die Angabe negativer Indizes bewirkt, dass der Abschnitt relativ zum Ende von buf und nicht zum Anfang generiert wird.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

console.log(buf.subarray(-6, -1).toString())
// Gibt aus: buffe
// (Äquivalent zu buf.subarray(0, 5).)

console.log(buf.subarray(-6, -2).toString())
// Gibt aus: buff
// (Äquivalent zu buf.subarray(0, 4).)

console.log(buf.subarray(-5, -2).toString())
// Gibt aus: uff
// (Äquivalent zu buf.subarray(1, 4).)

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from('buffer')

console.log(buf.subarray(-6, -1).toString())
// Gibt aus: buffe
// (Äquivalent zu buf.subarray(0, 5).)

console.log(buf.subarray(-6, -2).toString())
// Gibt aus: buff
// (Äquivalent zu buf.subarray(0, 4).)

console.log(buf.subarray(-5, -2).toString())
// Gibt aus: uff
// (Äquivalent zu buf.subarray(1, 4).)

buf.slice([start[, end]])

[Verlauf]

Version	Änderungen
v17.5.0, v16.15.0	Die Methode buf.slice() wurde als veraltet markiert.
v7.0.0	Alle Offsets werden nun vor jeglichen Berechnungen in Integer umgewandelt.
v7.1.0, v6.9.2	Die Umwandlung der Offsets in Integer behandelt nun Werte außerhalb des 32-Bit-Integer-Bereichs korrekt.
v0.3.0	Hinzugefügt in: v0.3.0

• start <integer> Wo der neue Buffer beginnt. Standardwert: 0.
• end <integer> Wo der neue Buffer endet (nicht inklusiv). Standardwert: buf.length.
• Rückgabewert: <Buffer>

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet: Verwenden Sie stattdessen buf.subarray.

Gibt einen neuen Buffer zurück, der auf denselben Speicher wie das Original verweist, aber durch die start und end Indizes verschoben und zugeschnitten ist.

Diese Methode ist nicht kompatibel mit Uint8Array.prototype.slice(), der eine Oberklasse von Buffer ist. Um den Slice zu kopieren, verwenden Sie Uint8Array.prototype.slice().

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

const copiedBuf = Uint8Array.prototype.slice.call(buf)
copiedBuf[0]++
console.log(copiedBuf.toString())
// Gibt aus: cuffer

console.log(buf.toString())
// Gibt aus: buffer

// Mit buf.slice() wird der originale Buffer modifiziert.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Gibt aus: cuffer
console.log(buf.toString())
// Gibt auch aus: cuffer (!)

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from('buffer')

const copiedBuf = Uint8Array.prototype.slice.call(buf)
copiedBuf[0]++
console.log(copiedBuf.toString())
// Gibt aus: cuffer

console.log(buf.toString())
// Gibt aus: buffer

// Mit buf.slice() wird der originale Buffer modifiziert.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Gibt aus: cuffer
console.log(buf.toString())
// Gibt auch aus: cuffer (!)

buf.swap16()

Hinzugefügt in: v5.10.0

• Rückgabewert: <Buffer> Ein Verweis auf buf.

Interpretiert buf als ein Array von vorzeichenlosen 16-Bit-Ganzzahlen und vertauscht die Byte-Reihenfolge in-place. Wirft ERR_INVALID_BUFFER_SIZE, wenn buf.length kein Vielfaches von 2 ist.

ESM

import { Buffer } from 'node:buffer'

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])

console.log(buf1)
// Gibt aus: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap16()

console.log(buf1)
// Gibt aus: <Buffer 02 01 04 03 06 05 08 07>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap16()
// Wirft ERR_INVALID_BUFFER_SIZE.

CJS

const { Buffer } = require('node:buffer')

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])

console.log(buf1)
// Gibt aus: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap16()

console.log(buf1)
// Gibt aus: <Buffer 02 01 04 03 06 05 08 07>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap16()
// Wirft ERR_INVALID_BUFFER_SIZE.

Eine praktische Anwendung von buf.swap16() ist die schnelle In-place-Konvertierung zwischen UTF-16 Little-Endian und UTF-16 Big-Endian:

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('This is little-endian UTF-16', 'utf16le')
buf.swap16() // Konvertiert zu Big-Endian UTF-16 Text.

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from('This is little-endian UTF-16', 'utf16le')
buf.swap16() // Konvertiert zu Big-Endian UTF-16 Text.

buf.swap32()

Hinzugefügt in: v5.10.0

• Rückgabewert: <Buffer> Ein Verweis auf buf.

Interpretiert buf als ein Array von vorzeichenlosen 32-Bit-Ganzzahlen und vertauscht die Byte-Reihenfolge in-place. Wirft ERR_INVALID_BUFFER_SIZE, wenn buf.length kein Vielfaches von 4 ist.

ESM

import { Buffer } from 'node:buffer'

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])

console.log(buf1)
// Gibt aus: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap32()

console.log(buf1)
// Gibt aus: <Buffer 04 03 02 01 08 07 06 05>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap32()
// Wirft ERR_INVALID_BUFFER_SIZE.

CJS

const { Buffer } = require('node:buffer')

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])

console.log(buf1)
// Gibt aus: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap32()

console.log(buf1)
// Gibt aus: <Buffer 04 03 02 01 08 07 06 05>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap32()
// Wirft ERR_INVALID_BUFFER_SIZE.

buf.swap64()

Hinzugefügt in: v6.3.0

• Rückgabewert: <Buffer> Ein Verweis auf buf.

Interpretiert buf als ein Array von 64-Bit-Zahlen und tauscht die Byte-Reihenfolge in-place aus. Wirft ERR_INVALID_BUFFER_SIZE, wenn buf.length kein Vielfaches von 8 ist.

ESM

import { Buffer } from 'node:buffer'

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])

console.log(buf1)
// Gibt aus: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap64()

console.log(buf1)
// Gibt aus: <Buffer 08 07 06 05 04 03 02 01>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap64()
// Wirft ERR_INVALID_BUFFER_SIZE.

CJS

const { Buffer } = require('node:buffer')

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])

console.log(buf1)
// Gibt aus: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap64()

console.log(buf1)
// Gibt aus: <Buffer 08 07 06 05 04 03 02 01>

const buf2 = Buffer.from([0x1, 0x2, 0x3])

buf2.swap64()
// Wirft ERR_INVALID_BUFFER_SIZE.

buf.toJSON()

Hinzugefügt in: v0.9.2

• Rückgabewert: <Object>

Gibt eine JSON-Darstellung von buf zurück. JSON.stringify() ruft diese Funktion implizit auf, wenn eine Buffer-Instanz serialisiert wird.

Buffer.from() akzeptiert Objekte im Format, das von dieser Methode zurückgegeben wird. Insbesondere funktioniert Buffer.from(buf.toJSON()) wie Buffer.from(buf).

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5])
const json = JSON.stringify(buf)

console.log(json)
// Gibt aus: {"type":"Buffer","data":[1,2,3,4,5]}

const copy = JSON.parse(json, (key, value) => {
  return value && value.type === 'Buffer' ? Buffer.from(value) : value
})

console.log(copy)
// Gibt aus: <Buffer 01 02 03 04 05>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5])
const json = JSON.stringify(buf)

console.log(json)
// Gibt aus: {"type":"Buffer","data":[1,2,3,4,5]}

const copy = JSON.parse(json, (key, value) => {
  return value && value.type === 'Buffer' ? Buffer.from(value) : value
})

console.log(copy)
// Gibt aus: <Buffer 01 02 03 04 05>

buf.toString([encoding[, start[, end]]])

Hinzugefügt in: v0.1.90

• encoding <string> Die zu verwendende Zeichenkodierung. Standard: 'utf8'.
• start <integer> Der Byte-Offset, an dem mit dem Decodieren begonnen werden soll. Standard: 0.
• end <integer> Der Byte-Offset, an dem das Decodieren beendet werden soll (nicht inklusiv). Standard: buf.length.
• Rückgabewert: <string>

Decodiert buf gemäß der angegebenen Zeichenkodierung in encoding in eine Zeichenkette. start und end können übergeben werden, um nur einen Teil von buf zu decodieren.

Wenn encoding 'utf8' ist und eine Byte-Sequenz in der Eingabe kein gültiges UTF-8 ist, wird jedes ungültige Byte durch das Ersetzungszeichen U+FFFD ersetzt.

Die maximale Länge einer Zeichenketteninstanz (in UTF-16-Codeeinheiten) ist als buffer.constants.MAX_STRING_LENGTH verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 ist der dezimale ASCII-Wert für 'a'.
  buf1[i] = i + 97
}

console.log(buf1.toString('utf8'))
// Gibt aus: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5))
// Gibt aus: abcde

const buf2 = Buffer.from('tést')

console.log(buf2.toString('hex'))
// Gibt aus: 74c3a97374
console.log(buf2.toString('utf8', 0, 3))
// Gibt aus: té
console.log(buf2.toString(undefined, 0, 3))
// Gibt aus: té

CJS

const { Buffer } = require('node:buffer')

const buf1 = Buffer.allocUnsafe(26)

for (let i = 0; i < 26; i++) {
  // 97 ist der dezimale ASCII-Wert für 'a'.
  buf1[i] = i + 97
}

console.log(buf1.toString('utf8'))
// Gibt aus: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5))
// Gibt aus: abcde

const buf2 = Buffer.from('tést')

console.log(buf2.toString('hex'))
// Gibt aus: 74c3a97374
console.log(buf2.toString('utf8', 0, 3))
// Gibt aus: té
console.log(buf2.toString(undefined, 0, 3))
// Gibt aus: té

buf.values()

Hinzugefügt in: v1.1.0

• Gibt zurück: <Iterator>

Erstellt und gibt einen Iterator für buf-Werte (Bytes) zurück. Diese Funktion wird automatisch aufgerufen, wenn ein Buffer in einer for..of-Anweisung verwendet wird.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.from('buffer')

for (const value of buf.values()) {
  console.log(value)
}
// Gibt aus:
//   98
//   117
//   102
//   102
//   101
//   114

for (const value of buf) {
  console.log(value)
}
// Gibt aus:
//   98
//   117
//   102
//   102
//   101
//   114

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.from('buffer')

for (const value of buf.values()) {
  console.log(value)
}
// Gibt aus:
//   98
//   117
//   102
//   102
//   101
//   114

for (const value of buf) {
  console.log(value)
}
// Gibt aus:
//   98
//   117
//   102
//   102
//   101
//   114

buf.write(string[, offset[, length]][, encoding])

Hinzugefügt in: v0.1.90

• string <string> Zeichenkette, die in buf geschrieben werden soll.
• offset <integer> Anzahl der Bytes, die übersprungen werden sollen, bevor mit dem Schreiben von string begonnen wird. Standard: 0.
• length <integer> Maximale Anzahl der zu schreibenden Bytes (geschriebene Bytes überschreiten nicht buf.length - offset). Standard: buf.length - offset.
• encoding <string> Die Zeichenkodierung von string. Standard: 'utf8'.
• Gibt zurück: <integer> Anzahl der geschriebenen Bytes.

Schreibt string gemäß der Zeichenkodierung in encoding an offset in buf. Der Parameter length ist die Anzahl der zu schreibenden Bytes. Wenn buf nicht genügend Platz für die gesamte Zeichenkette enthielt, wird nur ein Teil von string geschrieben. Teilweise kodierte Zeichen werden jedoch nicht geschrieben.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.alloc(256)

const len = buf.write('\u00bd + \u00bc = \u00be', 0)

console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`)
// Gibt aus: 12 bytes: ½ + ¼ = ¾

const buffer = Buffer.alloc(10)

const length = buffer.write('abcd', 8)

console.log(`${length} bytes: ${buffer.toString('utf8', 8, 10)}`)
// Gibt aus: 2 bytes : ab

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.alloc(256)

const len = buf.write('\u00bd + \u00bc = \u00be', 0)

console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`)
// Gibt aus: 12 bytes: ½ + ¼ = ¾

const buffer = Buffer.alloc(10)

const length = buffer.write('abcd', 8)

console.log(`${length} bytes: ${buffer.toString('utf8', 8, 10)}`)
// Gibt aus: 2 bytes : ab

buf.writeBigInt64BE(value[, offset])

Hinzugefügt in: v12.0.0, v10.20.0

• value <bigint> In buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss erfüllen: 0 \<= offset \<= buf.length - 8. Standard: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value als Big-Endian in buf an der angegebenen offset Stelle.

value wird als vorzeichenbehaftete Ganzzahl im Zweierkomplement interpretiert und geschrieben.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64BE(0x0102030405060708n, 0)

console.log(buf)
// Ausgabe: <Buffer 01 02 03 04 05 06 07 08>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64BE(0x0102030405060708n, 0)

console.log(buf)
// Ausgabe: <Buffer 01 02 03 04 05 06 07 08>

buf.writeBigInt64LE(value[, offset])

Hinzugefügt in: v12.0.0, v10.20.0

• value <bigint> In buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss erfüllen: 0 \<= offset \<= buf.length - 8. Standard: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value als Little-Endian in buf an der angegebenen offset Stelle.

value wird als vorzeichenbehaftete Ganzzahl im Zweierkomplement interpretiert und geschrieben.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64LE(0x0102030405060708n, 0)

console.log(buf)
// Ausgabe: <Buffer 08 07 06 05 04 03 02 01>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeBigInt64LE(0x0102030405060708n, 0)

console.log(buf)
// Ausgabe: <Buffer 08 07 06 05 04 03 02 01>

buf.writeBigUInt64BE(value[, offset])

[Historie]

Version	Änderungen
v14.10.0, v12.19.0	Diese Funktion ist auch als buf.writeBigUint64BE() verfügbar.
v12.0.0, v10.20.0	Hinzugefügt in: v12.0.0, v10.20.0

• value <bigint> Die in buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss erfüllen: 0 \<= offset \<= buf.length - 8. Standardwert: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value im Big-Endian-Format an die angegebene offset Stelle in buf.

Diese Funktion ist auch unter dem Alias writeBigUint64BE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64BE(0xdecafafecacefaden, 0)

console.log(buf)
// Ausgabe: <Buffer de ca fa fe ca ce fa de>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64BE(0xdecafafecacefaden, 0)

console.log(buf)
// Ausgabe: <Buffer de ca fa fe ca ce fa de>

buf.writeBigUInt64LE(value[, offset])

[Historie]

Version	Änderungen
v14.10.0, v12.19.0	Diese Funktion ist auch als buf.writeBigUint64LE() verfügbar.
v12.0.0, v10.20.0	Hinzugefügt in: v12.0.0, v10.20.0

• value <bigint> Die in buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss erfüllen: 0 \<= offset \<= buf.length - 8. Standardwert: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value im Little-Endian-Format an die angegebene offset Stelle in buf.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64LE(0xdecafafecacefaden, 0)

console.log(buf)
// Ausgabe: <Buffer de fa ce ca fe fa ca de>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeBigUInt64LE(0xdecafafecacefaden, 0)

console.log(buf)
// Ausgabe: <Buffer de fa ce ca fe fa ca de>

Diese Funktion ist auch unter dem Alias writeBigUint64LE verfügbar.

buf.writeDoubleBE(value[, offset])

[History]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.11.15	Hinzugefügt in: v0.11.15

• value <number> In buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 8 erfüllen. Standardwert: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value im Big-Endian-Format an die angegebene offset Stelle in buf. Der value muss eine JavaScript-Zahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine JavaScript-Zahl ist.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleBE(123.456, 0)

console.log(buf)
// Gibt aus: <Buffer 40 5e dd 2f 1a 9f be 77>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleBE(123.456, 0)

console.log(buf)
// Gibt aus: <Buffer 40 5e dd 2f 1a 9f be 77>

buf.writeDoubleLE(value[, offset])

[History]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.11.15	Hinzugefügt in: v0.11.15

• value <number> In buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 8 erfüllen. Standardwert: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value im Little-Endian-Format an die angegebene offset Stelle in buf. Der value muss eine JavaScript-Zahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine JavaScript-Zahl ist.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleLE(123.456, 0)

console.log(buf)
// Gibt aus: <Buffer 77 be 9f 1a 2f dd 5e 40>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(8)

buf.writeDoubleLE(123.456, 0)

console.log(buf)
// Gibt aus: <Buffer 77 be 9f 1a 2f dd 5e 40>

buf.writeFloatBE(value[, offset])

[Historie]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.11.15	Hinzugefügt in: v0.11.15

• value <number> In buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standardwert: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value als Big-Endian-Zahl in buf an der angegebenen offset-Position. Das Verhalten ist undefiniert, wenn value etwas anderes als eine JavaScript-Zahl ist.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeFloatBE(0xcafebabe, 0)

console.log(buf)
// Ausgabe: <Buffer 4f 4a fe bb>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeFloatBE(0xcafebabe, 0)

console.log(buf)
// Ausgabe: <Buffer 4f 4a fe bb>

buf.writeFloatLE(value[, offset])

[Historie]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.11.15	Hinzugefügt in: v0.11.15

• value <number> In buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standardwert: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value als Little-Endian-Zahl in buf an der angegebenen offset-Position. Das Verhalten ist undefiniert, wenn value etwas anderes als eine JavaScript-Zahl ist.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeFloatLE(0xcafebabe, 0)

console.log(buf)
// Ausgabe: <Buffer bb fe 4a 4f>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeFloatLE(0xcafebabe, 0)

console.log(buf)
// Ausgabe: <Buffer bb fe 4a 4f>

buf.writeInt8(value[, offset])

[History]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.0	Hinzugefügt in: v0.5.0

• value <integer> In buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor dem Schreiben übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 1 erfüllen. Standard: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value an die angegebene offset Stelle in buf. value muss eine gültige vorzeichenbehaftete 8-Bit-Ganzzahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenbehaftete 8-Bit-Ganzzahl ist.

value wird als vorzeichenbehaftete Zweierkomplement-Ganzzahl interpretiert und geschrieben.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

buf.writeInt8(2, 0)
buf.writeInt8(-2, 1)

console.log(buf)
// Gibt aus: <Buffer 02 fe>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(2)

buf.writeInt8(2, 0)
buf.writeInt8(-2, 1)

console.log(buf)
// Gibt aus: <Buffer 02 fe>

buf.writeInt16BE(value[, offset])

[History]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• value <integer> In buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor dem Schreiben übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 2 erfüllen. Standard: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value als Big-Endian an die angegebene offset Stelle in buf. value muss eine gültige vorzeichenbehaftete 16-Bit-Ganzzahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenbehaftete 16-Bit-Ganzzahl ist.

value wird als vorzeichenbehaftete Zweierkomplement-Ganzzahl interpretiert und geschrieben.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

buf.writeInt16BE(0x0102, 0)

console.log(buf)
// Gibt aus: <Buffer 01 02>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(2)

buf.writeInt16BE(0x0102, 0)

console.log(buf)
// Gibt aus: <Buffer 01 02>

buf.writeInt16LE(value[, offset])

[History]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• value <integer> In buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 2 erfüllen. Standardwert: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value im Little-Endian-Format an die angegebene offset Stelle in buf. Der value muss eine gültige vorzeichenbehaftete 16-Bit-Ganzzahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenbehaftete 16-Bit-Ganzzahl ist.

Der value wird als vorzeichenbehaftete Zweierkomplement-Ganzzahl interpretiert und geschrieben.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(2)

buf.writeInt16LE(0x0304, 0)

console.log(buf)
// Ausgabe: <Buffer 04 03>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(2)

buf.writeInt16LE(0x0304, 0)

console.log(buf)
// Ausgabe: <Buffer 04 03>

buf.writeInt32BE(value[, offset])

[History]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• value <integer> In buf zu schreibende Zahl.
• offset <integer> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standardwert: 0.
• Rückgabewert: <integer> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value im Big-Endian-Format an die angegebene offset Stelle in buf. Der value muss eine gültige vorzeichenbehaftete 32-Bit-Ganzzahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenbehaftete 32-Bit-Ganzzahl ist.

Der value wird als vorzeichenbehaftete Zweierkomplement-Ganzzahl interpretiert und geschrieben.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeInt32BE(0x01020304, 0)

console.log(buf)
// Ausgabe: <Buffer 01 02 03 04>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeInt32BE(0x01020304, 0)

console.log(buf)
// Ausgabe: <Buffer 01 02 03 04>

buf.writeInt32LE(value[, offset])

[Verlauf]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• value <Ganzzahl> In buf zu schreibende Zahl.
• offset <Ganzzahl> Anzahl der zu überspringenden Bytes vor Beginn des Schreibens. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standard: 0.
• Rückgabewert: <Ganzzahl> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value als Little-Endian in buf an der angegebenen offset Stelle. value muss eine gültige vorzeichenbehaftete 32-Bit-Ganzzahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenbehaftete 32-Bit-Ganzzahl ist.

value wird als Zweierkomplement-Ganzzahl interpretiert und geschrieben.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeInt32LE(0x05060708, 0)

console.log(buf)
// Ausgabe: <Buffer 08 07 06 05>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeInt32LE(0x05060708, 0)

console.log(buf)
// Ausgabe: <Buffer 08 07 06 05>

buf.writeIntBE(value, offset, byteLength)

[Verlauf]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets und der byteLength zu uint32 mehr.
v0.11.15	Hinzugefügt in: v0.11.15

• value <Ganzzahl> In buf zu schreibende Zahl.
• offset <Ganzzahl> Anzahl der zu überspringenden Bytes vor Beginn des Schreibens. Muss 0 \<= offset \<= buf.length - byteLength erfüllen.
• byteLength <Ganzzahl> Anzahl der zu schreibenden Bytes. Muss 0 \< byteLength \<= 6 erfüllen.
• Rückgabewert: <Ganzzahl> offset plus die Anzahl der geschriebenen Bytes.

Schreibt byteLength Bytes von value als Big-Endian in buf an der angegebenen offset Stelle. Unterstützt bis zu 48 Bit Genauigkeit. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenbehaftete Ganzzahl ist.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeIntBE(0x1234567890ab, 0, 6)

console.log(buf)
// Ausgabe: <Buffer 12 34 56 78 90 ab>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(6)

buf.writeIntBE(0x1234567890ab, 0, 6)

console.log(buf)
// Ausgabe: <Buffer 12 34 56 78 90 ab>

buf.writeIntLE(value, offset, byteLength)

[Historie]

Version	Änderungen
v10.0.0	noAssert entfernt und keine implizite Konvertierung von offset und byteLength mehr zu uint32.
v0.11.15	Hinzugefügt in: v0.11.15

• value <Ganzzahl> In buf zu schreibende Zahl.
• offset <Ganzzahl> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - byteLength erfüllen.
• byteLength <Ganzzahl> Anzahl der zu schreibenden Bytes. Muss 0 \< byteLength \<= 6 erfüllen.
• Rückgabewert: <Ganzzahl> offset plus die Anzahl der geschriebenen Bytes.

Schreibt byteLength Bytes von value an die angegebene offset Stelle in buf als Little-Endian. Unterstützt bis zu 48 Bit Genauigkeit. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenbehaftete Ganzzahl ist.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeIntLE(0x1234567890ab, 0, 6)

console.log(buf)
// Ausgabe: <Buffer ab 90 78 56 34 12>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(6)

buf.writeIntLE(0x1234567890ab, 0, 6)

console.log(buf)
// Ausgabe: <Buffer ab 90 78 56 34 12>

buf.writeUInt8(value[, offset])

[Historie]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.writeUint8() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung von offset mehr zu uint32.
v0.5.0	Hinzugefügt in: v0.5.0

• value <Ganzzahl> In buf zu schreibende Zahl.
• offset <Ganzzahl> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 1 erfüllen. Standardwert: 0.
• Rückgabewert: <Ganzzahl> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value an die angegebene offset Stelle in buf. value muss eine gültige vorzeichenlose 8-Bit-Ganzzahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenlose 8-Bit-Ganzzahl ist.

Diese Funktion ist auch unter dem Alias writeUint8 verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt8(0x3, 0)
buf.writeUInt8(0x4, 1)
buf.writeUInt8(0x23, 2)
buf.writeUInt8(0x42, 3)

console.log(buf)
// Ausgabe: <Buffer 03 04 23 42>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeUInt8(0x3, 0)
buf.writeUInt8(0x4, 1)
buf.writeUInt8(0x23, 2)
buf.writeUInt8(0x42, 3)

console.log(buf)
// Ausgabe: <Buffer 03 04 23 42>

buf.writeUInt16BE(value[, offset])

[Verlauf]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.writeUint16BE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• value <Ganzzahl> In buf zu schreibende Zahl.
• offset <Ganzzahl> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 2 erfüllen. Standard: 0.
• Rückgabewert: <Ganzzahl> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value als Big-Endian-Zahl in buf an der angegebenen offset Stelle. Der value muss eine gültige vorzeichenlose 16-Bit-Ganzzahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenlose 16-Bit-Ganzzahl ist.

Diese Funktion ist auch unter dem Alias writeUint16BE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16BE(0xdead, 0)
buf.writeUInt16BE(0xbeef, 2)

console.log(buf)
// Gibt aus: <Buffer de ad be ef>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16BE(0xdead, 0)
buf.writeUInt16BE(0xbeef, 2)

console.log(buf)
// Gibt aus: <Buffer de ad be ef>

buf.writeUInt16LE(value[, offset])

[Verlauf]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.writeUint16LE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• value <Ganzzahl> In buf zu schreibende Zahl.
• offset <Ganzzahl> Anzahl der Bytes, die vor Beginn des Schreibens übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 2 erfüllen. Standard: 0.
• Rückgabewert: <Ganzzahl> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value als Little-Endian-Zahl in buf an der angegebenen offset Stelle. Der value muss eine gültige vorzeichenlose 16-Bit-Ganzzahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenlose 16-Bit-Ganzzahl ist.

Diese Funktion ist auch unter dem Alias writeUint16LE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16LE(0xdead, 0)
buf.writeUInt16LE(0xbeef, 2)

console.log(buf)
// Gibt aus: <Buffer ad de ef be>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeUInt16LE(0xdead, 0)
buf.writeUInt16LE(0xbeef, 2)

console.log(buf)
// Gibt aus: <Buffer ad de ef be>

buf.writeUInt32BE(value[, offset])

[Verlauf]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.writeUint32BE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• value <Ganzzahl> Die in buf zu schreibende Zahl.
• offset <Ganzzahl> Anzahl der Bytes, die vor Beginn des Schreibvorgangs übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standard: 0.
• Rückgabewert: <Ganzzahl> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value im Big-Endian-Format an die angegebene offset Stelle in buf. value muss eine gültige vorzeichenlose 32-Bit-Ganzzahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenlose 32-Bit-Ganzzahl ist.

Diese Funktion ist auch unter dem Alias writeUint32BE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32BE(0xfeedface, 0)

console.log(buf)
// Ausgabe: <Buffer fe ed fa ce>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32BE(0xfeedface, 0)

console.log(buf)
// Ausgabe: <Buffer fe ed fa ce>

buf.writeUInt32LE(value[, offset])

[Verlauf]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.writeUint32LE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung des Offsets zu uint32 mehr.
v0.5.5	Hinzugefügt in: v0.5.5

• value <Ganzzahl> Die in buf zu schreibende Zahl.
• offset <Ganzzahl> Anzahl der Bytes, die vor Beginn des Schreibvorgangs übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - 4 erfüllen. Standard: 0.
• Rückgabewert: <Ganzzahl> offset plus die Anzahl der geschriebenen Bytes.

Schreibt value im Little-Endian-Format an die angegebene offset Stelle in buf. value muss eine gültige vorzeichenlose 32-Bit-Ganzzahl sein. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenlose 32-Bit-Ganzzahl ist.

Diese Funktion ist auch unter dem Alias writeUint32LE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32LE(0xfeedface, 0)

console.log(buf)
// Ausgabe: <Buffer ce fa ed fe>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(4)

buf.writeUInt32LE(0xfeedface, 0)

console.log(buf)
// Ausgabe: <Buffer ce fa ed fe>

buf.writeUIntBE(value, offset, byteLength)

[Verlauf]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.writeUintBE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung von offset und byteLength mehr zu uint32.
v0.5.5	Hinzugefügt in: v0.5.5

• value <Ganzzahl> In buf zu schreibende Zahl.
• offset <Ganzzahl> Anzahl der Bytes, die vor dem Schreiben übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - byteLength erfüllen.
• byteLength <Ganzzahl> Anzahl der zu schreibenden Bytes. Muss 0 \< byteLength \<= 6 erfüllen.
• Rückgabewert: <Ganzzahl> offset plus die Anzahl der geschriebenen Bytes.

Schreibt byteLength Bytes von value an die angegebene offset Stelle in buf als Big-Endian. Unterstützt bis zu 48 Bit Genauigkeit. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenlose Ganzzahl ist.

Diese Funktion ist auch unter dem Alias writeUintBE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeUIntBE(0x1234567890ab, 0, 6)

console.log(buf)
// Gibt aus: <Buffer 12 34 56 78 90 ab>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(6)

buf.writeUIntBE(0x1234567890ab, 0, 6)

console.log(buf)
// Gibt aus: <Buffer 12 34 56 78 90 ab>

buf.writeUIntLE(value, offset, byteLength)

[Verlauf]

Version	Änderungen
v14.9.0, v12.19.0	Diese Funktion ist auch als buf.writeUintLE() verfügbar.
v10.0.0	noAssert entfernt und keine implizite Konvertierung von offset und byteLength mehr zu uint32.
v0.5.5	Hinzugefügt in: v0.5.5

• value <Ganzzahl> In buf zu schreibende Zahl.
• offset <Ganzzahl> Anzahl der Bytes, die vor dem Schreiben übersprungen werden sollen. Muss 0 \<= offset \<= buf.length - byteLength erfüllen.
• byteLength <Ganzzahl> Anzahl der zu schreibenden Bytes. Muss 0 \< byteLength \<= 6 erfüllen.
• Rückgabewert: <Ganzzahl> offset plus die Anzahl der geschriebenen Bytes.

Schreibt byteLength Bytes von value an die angegebene offset Stelle in buf als Little-Endian. Unterstützt bis zu 48 Bit Genauigkeit. Das Verhalten ist undefiniert, wenn value etwas anderes als eine vorzeichenlose Ganzzahl ist.

Diese Funktion ist auch unter dem Alias writeUintLE verfügbar.

ESM

import { Buffer } from 'node:buffer'

const buf = Buffer.allocUnsafe(6)

buf.writeUIntLE(0x1234567890ab, 0, 6)

console.log(buf)
// Gibt aus: <Buffer ab 90 78 56 34 12>

CJS

const { Buffer } = require('node:buffer')

const buf = Buffer.allocUnsafe(6)

buf.writeUIntLE(0x1234567890ab, 0, 6)

console.log(buf)
// Gibt aus: <Buffer ab 90 78 56 34 12>

new Buffer(array)

[Verlauf]

Version	Änderungen
v10.0.0	Das Aufrufen dieses Konstruktors löst eine Deprecation-Warnung aus, wenn der Code außerhalb des Verzeichnisses node_modules ausgeführt wird.
v7.2.1	Das Aufrufen dieses Konstruktors löst keine Deprecation-Warnung mehr aus.
v7.0.0	Das Aufrufen dieses Konstruktors löst jetzt eine Deprecation-Warnung aus.
v6.0.0	Seit v6.0.0 veraltet

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet: Verwenden Sie stattdessen Buffer.from(array).

• array <integer[]> Ein Array von Bytes, das kopiert werden soll.

Siehe Buffer.from(array).

new Buffer(arrayBuffer[, byteOffset[, length]])

[Verlauf]

Version	Änderungen
v10.0.0	Das Aufrufen dieses Konstruktors löst eine Deprecation-Warnung aus, wenn der Code außerhalb des Verzeichnisses node_modules ausgeführt wird.
v7.2.1	Das Aufrufen dieses Konstruktors löst keine Deprecation-Warnung mehr aus.
v7.0.0	Das Aufrufen dieses Konstruktors löst jetzt eine Deprecation-Warnung aus.
v6.0.0	Die Parameter byteOffset und length werden jetzt unterstützt.
v6.0.0	Seit v6.0.0 veraltet
v3.0.0	Hinzugefügt in: v3.0.0

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet: Verwenden Sie stattdessen Buffer.from(arrayBuffer[, byteOffset[, length]]).

• arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> Ein ArrayBuffer, SharedArrayBuffer oder die .buffer-Eigenschaft eines TypedArray.
• byteOffset <integer> Index des ersten Bytes, das verfügbar gemacht werden soll. Standard: 0.
• length <integer> Anzahl der Bytes, die verfügbar gemacht werden sollen. Standard: arrayBuffer.byteLength - byteOffset.

Siehe Buffer.from(arrayBuffer[, byteOffset[, length]]).

new Buffer(buffer)

[Historie]

Version	Änderungen
v10.0.0	Der Aufruf dieses Konstruktors gibt eine Deprecation-Warnung aus, wenn er von Code außerhalb des node_modules-Verzeichnisses ausgeführt wird.
v7.2.1	Der Aufruf dieses Konstruktors gibt keine Deprecation-Warnung mehr aus.
v7.0.0	Der Aufruf dieses Konstruktors gibt jetzt eine Deprecation-Warnung aus.
v6.0.0	Seit v6.0.0 veraltet

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet: Verwenden Sie stattdessen Buffer.from(buffer).

• buffer <Buffer> | <Uint8Array> Ein vorhandenes Buffer oder Uint8Array, von dem Daten kopiert werden sollen.

Siehe Buffer.from(buffer).

new Buffer(size)

[Historie]

Version	Änderungen
v10.0.0	Der Aufruf dieses Konstruktors gibt eine Deprecation-Warnung aus, wenn er von Code außerhalb des node_modules-Verzeichnisses ausgeführt wird.
v8.0.0	new Buffer(size) gibt standardmäßig mit Null gefüllten Speicher zurück.
v7.2.1	Der Aufruf dieses Konstruktors gibt keine Deprecation-Warnung mehr aus.
v7.0.0	Der Aufruf dieses Konstruktors gibt jetzt eine Deprecation-Warnung aus.
v6.0.0	Seit v6.0.0 veraltet

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet: Verwenden Sie stattdessen Buffer.alloc() (siehe auch Buffer.allocUnsafe()).

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

Siehe Buffer.alloc() und Buffer.allocUnsafe(). Diese Variante des Konstruktors entspricht Buffer.alloc().

new Buffer(string[, encoding])

[Verlauf]

Version	Änderungen
v10.0.0	Das Aufrufen dieses Konstruktors löst eine Deprecation-Warnung aus, wenn es von Code außerhalb des Verzeichnisses node_modules ausgeführt wird.
v7.2.1	Das Aufrufen dieses Konstruktors löst keine Deprecation-Warnung mehr aus.
v7.0.0	Das Aufrufen dieses Konstruktors löst jetzt eine Deprecation-Warnung aus.
v6.0.0	Seit v6.0.0 veraltet

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet: Verwenden Sie stattdessen Buffer.from(string[, encoding]).

• string <string> Zu kodierender String.
• encoding <string> Die Kodierung von string. Standard: 'utf8'.

Siehe Buffer.from(string[, encoding]).

Klasse: File

[Verlauf]

Version	Änderungen
v23.0.0	Macht File-Instanzen klonbar.
v20.0.0	Nicht mehr experimentell.
v19.2.0, v18.13.0	Hinzugefügt in: v19.2.0, v18.13.0

• Erweitert: <Blob>

Ein File liefert Informationen über Dateien.

new buffer.File(sources, fileName[, options])

Hinzugefügt in: v19.2.0, v18.13.0

• sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> | <File[]> Ein Array von String-, <ArrayBuffer>-, <TypedArray>-, <DataView>-, <File>- oder <Blob>-Objekten, oder einer beliebigen Mischung solcher Objekte, die in der File gespeichert werden.
• fileName <string> Der Name der Datei.
• options <Object>
  • endings <string> Einer von 'transparent' oder 'native'. Wenn auf 'native' gesetzt, werden Zeilenumbrüche in String-Quellteilen in den plattformspezifischen Zeilenumbruch konvertiert, wie von require('node:os').EOL angegeben.
  • type <string> Der Content-Type der Datei.
  • lastModified <number> Das Datum der letzten Änderung der Datei. Standard: Date.now().

file.name

Hinzugefügt in: v19.2.0, v18.13.0

• Typ: <string>

Der Name der File.

file.lastModified

Hinzugefügt in: v19.2.0, v18.13.0

• Typ: <number>

Das Datum der letzten Änderung der File.

node:buffer Modul-APIs

Obwohl das Buffer-Objekt global verfügbar ist, gibt es zusätzliche Buffer-bezogene APIs, die nur über das node:buffer-Modul verfügbar sind, auf das mit require('node:buffer') zugegriffen wird.

buffer.atob(data)

Hinzugefügt in: v15.13.0, v14.17.0

[Stabil: 3 - Veraltet]

Stabil: 3 Stabilität: 3 - Veraltet. Verwenden Sie stattdessen Buffer.from(data, 'base64').

• data <any> Die Base64-kodierte Eingabezeichenkette.

Dekodiert eine Zeichenkette mit Base64-kodierten Daten in Bytes und kodiert diese Bytes mit Latin-1 (ISO-8859-1) in eine Zeichenkette.

data kann jeder JavaScript-Wert sein, der in eine Zeichenkette umgewandelt werden kann.

Diese Funktion wird nur zur Kompatibilität mit veralteten Web-Plattform-APIs bereitgestellt und sollte niemals in neuem Code verwendet werden, da sie Zeichenketten zur Darstellung binärer Daten verwenden und der Einführung von Typed Arrays in JavaScript vorausgehen. Für Code, der Node.js-APIs verwendet, sollte die Konvertierung zwischen Base64-kodierten Zeichenketten und binären Daten mit Buffer.from(str, 'base64') und buf.toString('base64') durchgeführt werden.

buffer.btoa(data)

Hinzugefügt in: v15.13.0, v14.17.0

[Stabil: 3 - Veraltet]

Stabil: 3 Stabilität: 3 - Veraltet. Verwenden Sie stattdessen buf.toString('base64').

• data <any> Eine ASCII (Latin1)-Zeichenkette.

Dekodiert eine Zeichenkette mit Latin-1 (ISO-8859) in Bytes und kodiert diese Bytes mit Base64 in eine Zeichenkette.

data kann jeder JavaScript-Wert sein, der in eine Zeichenkette umgewandelt werden kann.

Diese Funktion wird nur zur Kompatibilität mit veralteten Web-Plattform-APIs bereitgestellt und sollte niemals in neuem Code verwendet werden, da sie Zeichenketten zur Darstellung binärer Daten verwenden und der Einführung von Typed Arrays in JavaScript vorausgehen. Für Code, der Node.js-APIs verwendet, sollte die Konvertierung zwischen Base64-kodierten Zeichenketten und binären Daten mit Buffer.from(str, 'base64') und buf.toString('base64') durchgeführt werden.

buffer.isAscii(input)

Hinzugefügt in: v19.6.0, v18.15.0

• input <Buffer> | <ArrayBuffer> | <TypedArray> Die zu validierende Eingabe.
• Rückgabewert: <boolean>

Diese Funktion gibt true zurück, wenn input nur gültige ASCII-kodierte Daten enthält, einschließlich des Falls, in dem input leer ist.

Wirft einen Fehler, wenn input ein detached Array Buffer ist.

buffer.isUtf8(input)

Hinzugefügt in: v19.4.0, v18.14.0

• input <Buffer> | <ArrayBuffer> | <TypedArray> Die zu validierende Eingabe.
• Rückgabewert: <boolean>

Diese Funktion gibt true zurück, wenn input nur gültige UTF-8-kodierte Daten enthält, einschließlich des Falls, in dem input leer ist.

Wirft einen Fehler, wenn input ein detached Array Buffer ist.

buffer.INSPECT_MAX_BYTES

Hinzugefügt in: v0.5.4

• <integer> Standardwert: 50

Gibt die maximale Anzahl von Bytes zurück, die bei Aufruf von buf.inspect() zurückgegeben werden. Dies kann von Benutzermodulen überschrieben werden. Siehe util.inspect() für weitere Details zum Verhalten von buf.inspect().

buffer.kMaxLength

Hinzugefügt in: v3.0.0

• <integer> Die maximal zulässige Größe für eine einzelne Buffer-Instanz.

Ein Alias für buffer.constants.MAX_LENGTH.

buffer.kStringMaxLength

Hinzugefügt in: v3.0.0

• <integer> Die maximal zulässige Länge für eine einzelne string-Instanz.

Ein Alias für buffer.constants.MAX_STRING_LENGTH.

buffer.resolveObjectURL(id)

Hinzugefügt in: v16.7.0

[Stabil: 1 - Experimentell]

Stabil: 1 Stabilität: 1 - Experimentell

• id <string> Eine 'blob:nodedata:... URL-Zeichenkette, die von einem vorherigen Aufruf von URL.createObjectURL() zurückgegeben wurde.
• Rückgabewert: <Blob>

Löst eine 'blob:nodedata:... URL in ein zugeordnetes <Blob>-Objekt auf, das mit einem vorherigen Aufruf von URL.createObjectURL() registriert wurde.

buffer.transcode(source, fromEnc, toEnc)

[Verlauf]

Version	Änderungen
v8.0.0	Der Parameter source kann jetzt ein Uint8Array sein.
v7.1.0	Hinzugefügt in: v7.1.0

• source <Buffer> | <Uint8Array> Eine Buffer- oder Uint8Array-Instanz.
• fromEnc <string> Die aktuelle Kodierung.
• toEnc <string> Die Zielkodierung.
• Rückgabewert: <Buffer>

Kodiert die gegebene Buffer- oder Uint8Array-Instanz von einer Zeichenkodierung in eine andere um. Gibt eine neue Buffer-Instanz zurück.

Wirft einen Fehler, wenn fromEnc oder toEnc ungültige Zeichenkodierungen angeben oder wenn die Konvertierung von fromEnc nach toEnc nicht zulässig ist.

Von buffer.transcode() unterstützte Kodierungen sind: 'ascii', 'utf8', 'utf16le', 'ucs2', 'latin1' und 'binary'.

Der Transcodierungsprozess verwendet Ersatzzeichen, wenn eine gegebene Bytefolge nicht ausreichend in der Zielkodierung dargestellt werden kann. Beispielsweise:

ESM

import { Buffer, transcode } from 'node:buffer'

const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii')
console.log(newBuf.toString('ascii'))
// Gibt aus: '?'

CJS

const { Buffer, transcode } = require('node:buffer')

const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii')
console.log(newBuf.toString('ascii'))
// Gibt aus: '?'

Da das Euro-Zeichen (€) nicht in US-ASCII darstellbar ist, wird es im transcodierten Buffer durch ? ersetzt.

Klasse: SlowBuffer

Seit v6.0.0 veraltet

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet: Verwenden Sie stattdessen Buffer.allocUnsafeSlow().

Siehe Buffer.allocUnsafeSlow(). Dies war nie eine Klasse in dem Sinne, dass der Konstruktor immer eine Buffer-Instanz und nicht eine SlowBuffer-Instanz zurückgab.

new SlowBuffer(size)

Seit v6.0.0 veraltet

[Stabil: 0 - Veraltet]

Stabil: 0 Stabilität: 0 - Veraltet: Verwenden Sie stattdessen Buffer.allocUnsafeSlow().

• size <integer> Die gewünschte Länge des neuen SlowBuffer.

Siehe Buffer.allocUnsafeSlow().

Buffer-Konstanten

Hinzugefügt in: v8.2.0

buffer.constants.MAX_LENGTH

[Verlauf]

Version	Änderungen
v22.0.0	Wert geändert zu 2 - 1 auf 64-Bit-Architekturen.
v15.0.0	Wert geändert zu 2 auf 64-Bit-Architekturen.
v14.0.0	Wert geändert von 2 - 1 zu 2 - 1 auf 64-Bit-Architekturen.
v8.2.0	Hinzugefügt in: v8.2.0

• <integer> Die maximal zulässige Größe für eine einzelne Buffer-Instanz.

Auf 32-Bit-Architekturen beträgt dieser Wert derzeit 2 - 1 (ca. 1 GiB).

Auf 64-Bit-Architekturen beträgt dieser Wert derzeit 2 - 1 (ca. 8 PiB).

Er spiegelt intern v8::TypedArray::kMaxLength wider.

Dieser Wert ist auch als buffer.kMaxLength verfügbar.

buffer.constants.MAX_STRING_LENGTH

Hinzugefügt in: v8.2.0

• <integer> Die maximal zulässige Länge für eine einzelne string-Instanz.

Stellt die größte length dar, die ein string-Primitiv haben kann, gezählt in UTF-16-Codeeinheiten.

Dieser Wert kann von der verwendeten JS-Engine abhängen.

Buffer.from(), Buffer.alloc() und Buffer.allocUnsafe()

In Node.js-Versionen vor 6.0.0 wurden Buffer-Instanzen mithilfe der Buffer-Konstruktorfunktion erstellt, die den zurückgegebenen Buffer je nach bereitgestellten Argumenten unterschiedlich allokiert:

• Das Übergeben einer Zahl als erstes Argument an Buffer() (z. B. new Buffer(10)) allokiert ein neues Buffer-Objekt der angegebenen Größe. Vor Node.js 8.0.0 wird der für solche Buffer-Instanzen zugeteilte Speicher nicht initialisiert und kann sensible Daten enthalten. Solche Buffer-Instanzen müssen anschließend entweder mithilfe von buf.fill(0) oder durch Schreiben in den gesamten Buffer initialisiert werden, bevor Daten aus dem Buffer gelesen werden. Obwohl dieses Verhalten zur Verbesserung der Leistung beabsichtigt ist, hat die Entwicklungserfahrung gezeigt, dass eine explizitere Unterscheidung zwischen dem Erstellen eines schnellen, aber nicht initialisierten Buffer und dem Erstellen eines langsameren, aber sichereren Buffer erforderlich ist. Seit Node.js 8.0.0 geben Buffer(num) und new Buffer(num) einen Buffer mit initialisiertem Speicher zurück.
• Das Übergeben einer Zeichenkette, eines Arrays oder eines Buffer als erstes Argument kopiert die Daten des übergebenen Objekts in den Buffer.
• Das Übergeben eines ArrayBuffer oder eines SharedArrayBuffer gibt einen Buffer zurück, der den zugeordneten Speicher mit dem gegebenen Array-Buffer teilt.

Da sich das Verhalten von new Buffer() je nach Typ des ersten Arguments unterscheidet, können Sicherheits- und Zuverlässigkeitsprobleme unbeabsichtigt in Anwendungen eingeführt werden, wenn die Argumentvalidierung oder die Buffer-Initialisierung nicht durchgeführt wird.

Wenn beispielsweise ein Angreifer eine Anwendung dazu bringen kann, eine Zahl zu empfangen, wo eine Zeichenkette erwartet wird, kann die Anwendung new Buffer(100) anstelle von new Buffer("100") aufrufen, wodurch ein 100-Byte-Buffer anstelle eines 3-Byte-Buffers mit dem Inhalt "100" zugeordnet wird. Dies ist häufig mithilfe von JSON-API-Aufrufen möglich. Da JSON zwischen numerischen und Zeichenkettentypen unterscheidet, ermöglicht es die Injektion von Zahlen, wobei eine naiv geschriebene Anwendung, die ihre Eingabe nicht ausreichend validiert, möglicherweise immer eine Zeichenkette erwartet. Vor Node.js 8.0.0 könnte der 100-Byte-Buffer beliebige bereits vorhandene Daten im Speicher enthalten und somit verwendet werden, um Geheimnisse im Speicher an einen entfernten Angreifer preiszugeben. Seit Node.js 8.0.0 kann kein Speicher mehr offengelegt werden, da die Daten mit Null gefüllt sind. Andere Angriffe sind jedoch weiterhin möglich, z. B. das Veranlassen, dass vom Server sehr große Puffer zugeordnet werden, was zu Leistungseinbußen oder Abstürzen bei Speicherauslastung führt.

Um die Erstellung von Buffer-Instanzen zuverlässiger und fehlertoleranter zu gestalten, wurden die verschiedenen Formen des new Buffer()-Konstruktors veraltet und durch separate Buffer.from(), Buffer.alloc() und Buffer.allocUnsafe()-Methoden ersetzt.

Entwickler sollten alle vorhandenen Verwendungen der new Buffer()-Konstruktoren auf eine dieser neuen APIs migrieren.

• Buffer.from(array) gibt einen neuen Buffer zurück, der eine Kopie der bereitgestellten Oktette enthält.
• Buffer.from(arrayBuffer[, byteOffset[, length]]) gibt einen neuen Buffer zurück, der denselben zugeordneten Speicher wie der gegebene ArrayBuffer teilt.
• Buffer.from(buffer) gibt einen neuen Buffer zurück, der eine Kopie des Inhalts des gegebenen Buffer enthält.
• Buffer.from(string[, encoding]) gibt einen neuen Buffer zurück, der eine Kopie der bereitgestellten Zeichenkette enthält.
• Buffer.alloc(size[, fill[, encoding]]) gibt einen neuen initialisierten Buffer der angegebenen Größe zurück. Diese Methode ist langsamer als Buffer.allocUnsafe(size), garantiert aber, dass neu erstellte Buffer-Instanzen niemals alte Daten enthalten, die möglicherweise sensibel sind. Ein TypeError wird ausgelöst, wenn size keine Zahl ist.
• Buffer.allocUnsafe(size) und Buffer.allocUnsafeSlow(size) geben jeweils einen neuen nicht initialisierten Buffer der angegebenen size zurück. Da der Buffer nicht initialisiert ist, kann das zugewiesene Speichersegment alte Daten enthalten, die möglicherweise sensibel sind.

Buffer-Instanzen, die von Buffer.allocUnsafe(), Buffer.from(string), Buffer.concat() und Buffer.from(array) zurückgegeben werden, können einem gemeinsam genutzten internen Speicherpool zugeordnet werden, wenn size kleiner oder gleich der Hälfte von Buffer.poolSize ist. Instanzen, die von Buffer.allocUnsafeSlow() zurückgegeben werden, verwenden nie den gemeinsam genutzten internen Speicherpool.

Die Kommandozeilenoption --zero-fill-buffers

Hinzugefügt in: v5.10.0

Node.js kann mit der Kommandozeilenoption --zero-fill-buffers gestartet werden, um sicherzustellen, dass alle neu zugewiesenen Buffer-Instanzen standardmäßig bei der Erstellung mit Nullen gefüllt werden. Ohne diese Option werden Puffer, die mit Buffer.allocUnsafe(), Buffer.allocUnsafeSlow() und new SlowBuffer(size) erstellt werden, nicht mit Nullen gefüllt. Die Verwendung dieses Flags kann messbare negative Auswirkungen auf die Leistung haben. Verwenden Sie die Option --zero-fill-buffers nur dann, wenn dies erforderlich ist, um sicherzustellen, dass neu zugewiesene Buffer-Instanzen keine alten, potenziell sensiblen Daten enthalten können.

$ node --zero-fill-buffers
> Buffer.allocUnsafe(5);
<Buffer 00 00 00 00 00>

Was macht Buffer.allocUnsafe() und Buffer.allocUnsafeSlow() "unsicher"?

Beim Aufruf von Buffer.allocUnsafe() und Buffer.allocUnsafeSlow() ist das Segment des zugewiesenen Speichers nicht initialisiert (es wird nicht auf Null gesetzt). Obwohl dieses Design die Zuweisung von Speicher ziemlich schnell macht, kann das zugewiesene Speichersegment alte Daten enthalten, die potenziell sensibel sind. Die Verwendung eines Puffers, der mit Buffer.allocUnsafe() erstellt wurde, ohne den Speicher vollständig zu überschreiben, kann dazu führen, dass diese alten Daten auslaufen, wenn der Puffer-Speicher gelesen wird.

Obwohl die Verwendung von Buffer.allocUnsafe() klare Leistungsvorteile bietet, muss besondere Sorgfalt angewendet werden, um Sicherheitslücken in einer Anwendung zu vermeiden.