Detaillierte Erläuterung der Node.js-Puffernutzung

Dieses Mal erkläre ich Ihnen ausführlich die Verwendung von Node.js Buffer und welche Vorsichtsmaßnahmen bei der Verwendung von Node.js Buffer gelten. Das Folgende ist ein praktischer Fall , lass uns einen Blick darauf werfen.

Was ist Puffer?

Buffer existiert als globales Objekt und kann ohne Einführung eines Moduls verwendet werden. Sie dürfen es nicht ignorieren.

Es versteht sich, dass Puffer ein im Speicher geöffneter Bereich zum Speichern von Binärdaten ist. Puffer öffnet Off-Heap-Speicher.

Was sind die Anwendungsszenarien von Buffer?

Flow

Wie versteht man Flow? Stream ist eine Sammlung von Daten (ähnlich wie Daten, String), aber die Daten des Streams können nicht auf einmal abgerufen werden und die Daten werden nicht alle in den Speicher geladen Sehr gut geeignet für die Verarbeitung großer Datenmengen und die intermittierende Rückgabe. Die externe Quelle des Blocks. Die Geschwindigkeit zwischen Stream-Produzenten und -Konsumenten ist normalerweise inkonsistent, daher sind Puffer erforderlich, um einige Daten vorübergehend zu speichern. Die Puffergröße wird durch den Parameter highWaterMark angegeben, der standardmäßig 16 KB beträgt.

Speichern von Daten, die viel Speicher erfordern

Der vom Buffer-Objekt belegte Speicherplatz wird nicht in das Speicherplatzlimit des Node.js-Prozesses eingerechnet, sodass dies möglich ist zur Lagerung verwendet werden Große Objekte, aber die Größe des Objekts ist noch begrenzt. Im Allgemeinen umfasst ein 32-Bit-System etwa 1 GB und ein 64-Bit-System etwa 2 GB.

So erstellen Sie einen Puffer

Zusätzlich zur impliziten automatischen Erstellung eines Puffers durch den Stream können Sie einen Puffer auch manuell wie folgt erstellen:

Die in Buffer gespeicherten Daten wurden bestimmt

Buffer.from(obj) // Die von obj unterstützten Typen string, buffer, arrayBuffer, array, or array- like object

Hinweis: Buffer.from unterstützt die Übergabe von Zahlen nicht, wie unten gezeigt:

Buffer.from(1234);
buffer.js:208
  throw new errors.TypeError(
  ^
TypeError [ERR_INVALID_ARG_TYPE]: The "value" argument must not be of type number. Received type number
  at Function.from (buffer.js:208:11)
  ...

Wenn Sie Zahlen übergeben möchten, können Sie ein Array übergeben:

const buf = Buffer.from([1, 2, 3, 4]);
console.log(buf); // <Buffer 01 02 03 04>

Aber es gibt ein Problem: Wenn unterschiedliche Werte gespeichert werden, sind die im Puffer aufgezeichneten Binärdaten gleich, wie unten gezeigt:

const buf2 = Buffer.from([127, -1]);
console.log(buf2);   // <Buffer 7f ff>
const buf3 = Buffer.from([127, 255]);
console.log(buf3);  // <Buffer 7f ff>
console.log(buf3.equals(buf2)); // true

Wenn eine Reihe von Zahlen aufgezeichnet werden soll Alle liegen zwischen 0 und 255 (readUInt8 zum Lesen) in diesem Bereich, oder wenn sie alle in den Bereich von -128 bis 127 (readInt8 zum Lesen) fallen, gibt es kein Problem. Andernfalls wird die Verwendung von Buffer dringend empfohlen .from, um eine Reihe von Zahlen zu speichern. Weil beim Lesen unterschiedlicher Zahlen unterschiedliche Methoden aufgerufen werden sollten.

Pufferspeicherdaten werden nicht ermittelt

Buffer.alloc, Buffer.allocUnsafe, Buffer.allocUnsafeSlow

Buffer.alloc will Füllt den zugewiesenen Speicher mit 0 Werten, ist also langsamer als die beiden letztgenannten, aber auch sicherer. Natürlich können Sie auch das Flag --zero-fill-buffers verwenden, um allocUnsafe und allocUnsafeSlow nach der Speicherzuweisung mit Nullwerten füllen zu lassen.

node --zero-fill-buffers index.js

Wenn der zugewiesene Speicherplatz weniger als 4 KB beträgt, schneidet allocUnsafe den Speicherplatz direkt aus dem zuvor zugewiesenen Puffer ab, sodass die Geschwindigkeit schneller ist als bei allocUnsafeSlow. Wenn der zugewiesene Speicherplatz größer oder gleich 4 KB ist, Es gibt keinen Geschwindigkeitsunterschied zwischen den beiden.

// 分配空间等于4KB
function createBuffer(fn, size) {
 console.time('buf-' + fn);
 for (var i = 0; i < 100000; i++) {
  Buffer[fn](size);
 }
 console.timeEnd(&#39;buf-&#39; + fn);
}
createBuffer(&#39;alloc&#39;, 4096);
createBuffer(&#39;allocUnsafe&#39;, 4096);
createBuffer(&#39;allocUnsafeSlow&#39;, 4096);
// 输出
buf-alloc:      294.002ms
buf-allocUnsafe:   224.072ms
buf-allocUnsafeSlow: 209.22ms

rrree

Eines sollten Sie beachten: Die neue Buffer(xxxx)-Methode wird nicht mehr empfohlen

Puffer verwenden

Puffer zu String

function createBuffer(fn, size) {
 console.time('buf-' + fn);
 for (var i = 0; i < 100000; i++) {
  Buffer[fn](size);
 }
 console.timeEnd(&#39;buf-&#39; + fn);
}
createBuffer(&#39;alloc&#39;, 4095);
createBuffer(&#39;allocUnsafe&#39;, 4095);
createBuffer(&#39;allocUnsafeSlow&#39;, 4095);
// 输出
buf-alloc:      296.965ms
buf-allocUnsafe:   135.877ms
buf-allocUnsafeSlow: 205.225ms

Puffer zu JSON

const buf = Buffer.from('test');
console.log(buf.toString('utf8'));         // test
console.log(buf.toString('utf8', 0, 2));      // te

Puffer-Clipping, der neue Puffer wird nach dem Clipping auf den gleichen Punkt wie der zurückgegeben Originalpuffer Ein Stück Erinnerung

const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5]);
console.log(buf.toJSON());  // { type: 'Buffer', data: [ 1, 2, 3, 4, 5 ] }

1. Start Startposition

2. Endendposition (nicht im Lieferumfang enthalten)

Beispiel:

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

Pufferkopie, Puffer unterscheidet sich vom Array, die Länge des Puffers ändert sich nicht, sobald sie bestimmt ist. Wenn also der kopierte Quellpuffer größer als der Zielpuffer ist, wird nur ein Teil davon geändert Der Wert wird kopiert

var buf1 = Buffer.from('test');
var buf2 = buf1.slice(1, 3).fill('xx');
console.log("buf2 content: " + buf2.toString()); // xx
console.log("buf1 content: " + buf1.toString()); // txxt

Beispiel:

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

Puffergleichheitsbeurteilung, Vergleich von Binärwerten

var buf1 = Buffer.from('abcdefghijkl');
var buf2 = Buffer.from('ABCDEF');
buf1.copy(buf2, 1);
console.log(buf2.toString()); //Abcdef

Beispiel:

buf.equals(otherBuffer)

Zusätzlich zu Gleichheit kann Vergleichen tatsächlich auch verwendet werden, um zu bestimmen, ob sie gleich sind (wenn das Ergebnis 0 ist, sind sie gleich), aber die Hauptfunktion von Vergleichen besteht darin, die Pufferinstanzen im Array zu sortieren.

Ob der Puffer einen bestimmten Wert enthält

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

示例：

const buf = Buffer.from('this is a buffer');
console.log(buf.includes('this')); // true
console.log(buf.indexOf('this')); // 0

写入读取数值

写入方法：

位数固定且超过1个字节的： write{Double| Float | Int16 | Int32| UInt16 | UInt32 }{BE|LE}(value, offset)

位数不固定的： write{Int | UInt}{BE | LE}(value, offset, bytelength) //此方法提供了更灵活的位数表示数据（比如3位、5位）

位数固定是1个字节的： write{Int8 | Unit8}(value, offset)

读取方法：

位数固定且超过1个字节的： read{Double| Float | Int16 | Int32 | UInt16 | UInt32 }{BE|LE}（offset)

位数不固定的： read{Int | UInt}{BE | LE}(offset, byteLength)

位数固定是1个字节的： read{Int8 | Unit8}(offset)

Double、Float、Int16、Int32、UInt16、UInt32既确定了表征数字的位数，也确定了是否包含负数，因此定义了不同的数据范围。同时由于表征数字的位数都超过8位，无法用一个字节来表示，因此就涉及到了计算机的字节序区分（大端字节序与小端字节序）

关于大端小端的区别可以这么理解：数值的高位在buffer的起始位置的是大端，数值的低位buffer的起始位置则是小端

const buf = Buffer.allocUnsafe(2);
buf.writeInt16BE(256, 0) 
console.log(buf);      // <Buffer 01 00> 
buf.writeInt16LE(256, 0)
console.log(buf);      // <Buffer 00 01>

http://tools.jb51.net/transcoding/hexconvert这里可以查看数值的不同进制之间的转换，如果是大端的话，则直接按顺序（0100）拼接16进制即可，如果是小端则需要调换一下顺序才是正确的表示方式。

buffer合并

Buffer.concat(list[, totalLength]) //totalLength不是必须的，如果不提供的话会为了计算totalLength会多一次遍历

const buf1 = Buffer.from('this is');
const buf2 = Buffer.from(' funny');
console.log(Buffer.concat([buf1, buf2], buf1.length + buf2.length));
// <Buffer 74 68 69 73 20 69 73 20 66 75 6e 6e 79>

清空buffer

清空buffer数据最快的办法是buffer.fill(0)

buffer模块与Buffer的关系

Buffer是全局global上的一个引用，指向的其实是buffer.Buffer

 const buffer = require('buffer');
 console.log(buffer.Buffer === Buffer); //true

buffer模块上还有其他一些属性和方法

const buffer = require('buffer');
console.log(buffer);
{ Buffer:
  { [Function: Buffer]
   poolSize: 8192,
   from: [Function: from],
   alloc: [Function: alloc],
   allocUnsafe: [Function: allocUnsafe],
   allocUnsafeSlow: [Function: allocUnsafeSlow],
   isBuffer: [Function: isBuffer],
   compare: [Function: compare],
   isEncoding: [Function: isEncoding],
   concat: [Function: concat],
   byteLength: [Function: byteLength],
   [Symbol(node.isEncoding)]: [Function: isEncoding] },
 SlowBuffer: [Function: SlowBuffer],
 transcode: [Function: transcode],
 INSPECT_MAX_BYTES: 50,
 kMaxLength: 2147483647,
 kStringMaxLength: 1073741799,
 constants: { MAX_LENGTH: 2147483647, MAX_STRING_LENGTH: 1073741799 } }

上面的kMaxLength与MAX_LENGTH代表了新建buffer时内存大小的最大值，当超过限制值后就会报错

32为机器上是(2^30)-1(~1GB)

64位机器上是(2^31)-1(~2GB)

Buffer释放

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

如何搭建React全家桶环境

怎样使用JS实现调用本地摄像头

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Node.js-Puffernutzung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!