Node.js Buffer

Die JavaScript-Sprache selbst hat nur einen String-Datentyp und keinen Binärdatentyp.

Die Buffer-Klasse in Node.js ist ein Kernwerkzeug für den Umgang mit Binärdaten und bietet effiziente Operationen für Binärdaten.

Die Buffer-Klasse ist besonders nützlich in Szenarien wie Dateioperationen, Netzwerkkommunikation und Bildverarbeitung.

Funktionen:

• Binärdaten：BufferDas Objekt ist ein Array fester Größe, das Rohbinärdaten enthält. Jedes Element belegt ein Byte (8 Bits), daherBufferes ist für die Verarbeitung von Binärdaten geeignet, wie Dateiinhalte, Netzwerkpakete usw.
• Unveränderlichkeit: ObwohlBufferder Inhalt des Objekts nach der Erstellung geändert werden kann, ist seine Länge fest und kann nicht dynamisch geändert werden.

Buffer und Zeichenkodierungen

Buffer-Instanzen werden im Allgemeinen verwendet, um Sequenzen codierter Zeichen darzustellen, wie UTF-8, UCS2, Base64 oder hexadezimal codierte Daten. Durch die Verwendung expliziter Zeichenkodierungen kann zwischen Buffer-Instanzen und gewöhnlichen JavaScript-Zeichenketten konvertiert werden.

Die derzeit von Node.js unterstützten Zeichenkodierungen umfassen:

• ascii- Es werden nur 7-Bit-ASCII-Daten unterstützt. Diese Kodierung ist sehr schnell, wenn das High-Bit entfernt wird.

• utf8- Unicode-Zeichen, als Multibyte kodiert. Viele Webseiten und andere Dokumentformate verwenden UTF-8.

• utf16le- 2 oder 4 Bytes, Little-Endian-kodierte Unicode-Zeichen. Unterstützt Surrogatpaare (U+10000 bis U+10FFFF).

• ucs2 - utf16leAlias von .

• base64- Base64-Kodierung.

• latin1- Eine Möglichkeit, einenBufferin einen einbyte-kodierten String zu kodieren.

• binary - latin1Alias von .

• hex- Kodiert jedes Byte in zwei hexadezimale Zeichen.

Erstellen einer Buffer-Klasse

Buffer bietet die folgenden APIs zum Erstellen einer Buffer-Klasse:

• Buffer.alloc(size[, fill[, encoding]]):Erstellt einen Buffer mit einer Länge von size Bytes, was dem Zuweisen von size Bytes Speicherplatz entspricht, wobei jeder Byte-Wert 0 ist.
• Buffer.allocUnsafe(size):Erstellt einen Buffer mit einer Länge von size Bytes, aber der Buffer kann alte Daten enthalten, was das Ausführungsergebnis beeinflussen kann, daher der Name unsafe.
• Buffer.allocUnsafeSlow(size):Wird verwendet, um eine neue Buffer-Instanz der angegebenen Größe zuzuweisen, aber ohne sie zu initialisieren.
• Buffer.from(array):Gibt eine neue Buffer-Instanz zurück, die mit den Werten von array initialisiert wurde (die Elemente des übergebenen Arrays dürfen nur Zahlen sein, andernfalls werden sie automatisch durch 0 überschrieben).
• Buffer.from(arrayBuffer[, byteOffset[, length]]):Gibt einen neu erstellten Buffer zurück, der denselben Speicher wie der angegebene ArrayBuffer gemeinsam nutzt.
• Buffer.from(buffer):Kopiert die Daten der übergebenen Buffer-Instanz und gibt eine neue Buffer-Instanz zurück.
• Buffer.from(string[, encoding]):Erstellt einen Buffer aus einem String; eine Kodierung kann angegeben werden, standardmäßig UTF-8.

In Buffer schreiben

Syntax

Die Syntax zum Schreiben in einen Node-Buffer lautet wie folgt:

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

Parameters

Die Parameter werden wie folgt beschrieben:

• string- Der String, der in den Buffer geschrieben werden soll.

• offset- Der Indexwert, an dem der Buffer mit dem Schreiben beginnt; standardmäßig 0.

• length- Die Anzahl der zu schreibenden Bytes, standardmäßig buffer.length.

• encoding- Die zu verwendende Kodierung. Standardmäßig 'utf8'.

Schreibt string an der offset-Position in buf gemäß der Zeichenkodierung von encoding. Der Parameter length ist die Anzahl der zu schreibenden Bytes. Wenn buf nicht genügend Platz bietet, um den gesamten string aufzunehmen, wird nur ein Teil von string geschrieben. Teilweise dekodierte Zeichen werden nicht geschrieben.

Rückgabewert

Gibt die tatsächlich geschriebene Größe zurück. Wenn der Pufferplatz nicht ausreicht, wird nur ein Teil des Strings geschrieben.

Beispiel

buf = Buffer.alloc(256);
len = buf.write("www.example.com");

console.log("写入字节数 : "+  len);

Führen Sie den obigen Code aus, und das Ausgabeergebnis ist:

$node main.js
写入字节数 : 14

Daten aus Buffer lesen

Syntax

Die Syntax zum Lesen von Node-Buffer-Daten lautet wie folgt:

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

Parameters

Die Parameter werden wie folgt beschrieben:

• encoding- Die zu verwendende Kodierung. Standardmäßig 'utf8'.

• start- Gibt die Indexposition an, ab der gelesen werden soll; standardmäßig 0.

• end- Die Endposition, standardmäßig das Ende des Buffers.

Rückgabewert

Dekodiert Buffer-Daten und gibt unter Verwendung der angegebenen Kodierung einen String zurück.

Beispiel

buf = Buffer.alloc(26);
for (var i = 0 ; i < 26 ; i++) {
  buf[i] = i + 97;
}

console.log( buf.toString('ascii'));       // 输出: abcdefghijklmnopqrstuvwxyz
console.log( buf.toString('ascii',0,5));   //使用 'ascii' 编码, 并输出: abcde
console.log( buf.toString('utf8',0,5));    // 使用 'utf8' 编码, 并输出: abcde
console.log( buf.toString(undefined,0,5)); // 使用默认的 'utf8' 编码, 并输出: abcde

Führen Sie den obigen Code aus, und das Ausgabeergebnis ist:

$ node main.js
abcdefghijklmnopqrstuvwxyz
abcde
abcde
abcde

Konvertieren von Buffer in JSON-Objekt

Syntax

Das Syntaxformat der Funktion zum Konvertieren eines Node-Buffers in ein JSON-Objekt lautet wie folgt:

buf.toJSON()

Beim Stringifizieren einer Buffer-Instanz,JSON.stringify()wird diese Methode implizit aufgerufen.toJSON()。

Rückgabewert

Gibt ein JSON-Objekt zurück.

Beispiel

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

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

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

// 输出: <Buffer 01 02 03 04 05>
console.log(copy);

Führen Sie den obigen Code aus, und das Ausgabeergebnis ist:

{"type":"Buffer","data":[1,2,3,4,5]}
<Buffer 01 02 03 04 05>

Buffer-Verkettung

Syntax

Die Syntax für die Node-Buffer-Verkettung lautet wie folgt:

Buffer.concat(list[, totalLength])

Parameters

Die Parameter werden wie folgt beschrieben:

• list- Eine Array-Liste von Buffer-Objekten, die verkettet werden sollen.

• totalLength- Gibt die Gesamtlänge des verketteten Buffer-Objekts an.

Rückgabewert

Gibt ein neues Buffer-Objekt zurück, das durch Verketten mehrerer Elemente gebildet wird.

Beispiel

var buffer1 = Buffer.from(('Example'));
var buffer2 = Buffer.from(('www.example.com'));
var buffer3 = Buffer.concat([buffer1,buffer2]);
console.log("buffer3 内容: " + buffer3.toString());

Führen Sie den obigen Code aus, und das Ausgabeergebnis ist:

buffer3 内容: Examplewww.example.com

Buffer-Vergleich

Syntax

Die Funktionssyntax für den Node-Buffer-Vergleich lautet wie folgt. Diese Methode wurde in Node.js v0.12.2 eingeführt:

buf.compare(otherBuffer);

Parameters

Die Parameter werden wie folgt beschrieben:

• otherBuffer- ein anderes Buffer-Objekt, das mitbufverglichen wird.

Rückgabewert

Gibt eine Zahl zurück, die angibt, obbufin Bezug aufotherBufferdavor, danach oder gleich ist.

Beispiel

var buffer1 = Buffer.from('ABC');
var buffer2 = Buffer.from('ABCD');
var result = buffer1.compare(buffer2);

if(result < 0) {
   console.log(buffer1 + " 在 " + buffer2 + "之前");
}else if(result == 0){
   console.log(buffer1 + " 与 " + buffer2 + "相同");
}else {
   console.log(buffer1 + " 在 " + buffer2 + "之后");
}

Führen Sie den obigen Code aus, und das Ausgabeergebnis ist:

ABC在ABCD之前

Buffer kopieren

Syntax

Die Syntax zum Kopieren von Node-Buffer lautet wie folgt:

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

Parameters

Die Parameter werden im Folgenden beschrieben:

• targetBuffer- Das zu kopierende Buffer-Objekt.

• targetStart- Zahl, optional, Standardwert: 0

• sourceStart- Zahl, optional, Standardwert: 0

• sourceEnd- Zahl, optional, Standardwert: buffer.length

Rückgabewert

Kein Rückgabewert.

Beispiel

var buf1 = Buffer.from('abcdefghijkl');
var buf2 = Buffer.from('EXAMPLE');

//将 buf2 插入到 buf1 指定位置上
buf2.copy(buf1, 2);

console.log(buf1.toString());

Das Ausführen des obigen Codes liefert das folgende Ergebnis:

abEXAMPLEijkl

Buffer-Slice

Die Syntax zum Slicing von Node-Buffer lautet wie folgt:

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

Parameters

Die Parameter werden im Folgenden beschrieben:

• start- Zahl, optional, Standardwert: 0

• end- Zahl, optional, Standardwert: buffer.length

Rückgabewert

Gibt einen Buffer zurück, der auf denselben Speicher wie der alte Buffer zeigt, aber von start bis end geschnitten ist.

Beispiel

var buffer1 = Buffer.from('example');
// 剪切缓冲区
var buffer2 = buffer1.slice(0,2);
console.log("buffer2 content: " + buffer2.toString());

Das Ausführen des obigen Codes liefert das folgende Ergebnis:

buffer2 content: ru

Buffer-Länge

Syntax

Die Syntax zur Berechnung der Node-Buffer-Länge lautet wie folgt:

buf.length;

Rückgabewert

Gibt die vom Buffer-Objekt belegte Speicherlänge zurück.

Beispiel

var buffer = Buffer.from('www.example.com');
//  缓冲区长度
console.log("buffer length: " + buffer.length);

Das Ausführen des obigen Codes liefert das folgende Ergebnis:

buffer length: 14

Referenzhandbuch für Methoden

Die folgende Liste enthält die häufig verwendeten Methoden des Node.js-Buffer-Moduls (beachten Sie, dass einige Methoden in älteren Versionen nicht verfügbar sind):

const buf = Buffer.allocUnsafe(6);

buf.writeUIntLE(0x1234567890ab, 0, 6);

// 输出: <Buffer ab 90 78 56 34 12>
console.log(buf);

const buf = Buffer.allocUnsafe(6);

buf.writeUIntBE(0x1234567890ab, 0, 6);

// 输出: <Buffer 12 34 56 78 90 ab>
console.log(buf);