Detaillierte Erläuterung gängiger APIs des Nodejs-Puffermoduls

Dieser Artikel gibt Ihnen eine detaillierte Einführung in die gängigen APIs des Nodejs Buffer-Moduls. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird für alle hilfreich sein.

Modulübersicht

Buffer ist das Kernmodul von Node. Entwickler können es zum Verarbeiten von Binärdaten verwenden, z. B. zum Lesen und Schreiben von Dateiströmen, zum Verarbeiten von Netzwerkanforderungsdaten usw.

Buffer verfügt über viele APIs. In diesem Artikel werden nur die am häufigsten verwendeten/leicht verständlichen APIs erläutert, einschließlich der Erstellung, des Vergleichs, der Verbindung, des Kopierens, der Suche, des Durchlaufens, der Typkonvertierung, des Abfangens, der Codierungskonvertierung usw Pufferinstanzen. [Empfohlenes Lernen: „nodejs-Tutorial“]

Erstellen

• neuen Puffer(array)
• Buffer.alloc(länge)
• Buffer.allocUnsafe(länge)
• Buffer.from(array)

By new Buffer(array)

// Creates a new Buffer containing the ASCII bytes of the string 'buffer'
const buf = new Buffer([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);

Überprüfen:

var array = 'buffer'.split('').map(function(v){
    return '0x' + v.charCodeAt(0).toString(16)
});

console.log( array.join() );
// 输出：0x62,0x75,0x66,0x66,0x65,0x72

By Buffer.alloc(length)

var buf1 = Buffer.alloc(10);  // 长度为10的buffer，初始值为0x0
var buf2 = Buffer.alloc(10, 1);  // 长度为10的buffer，初始值为0x1

var buf3 = Buffer.allocUnsafe(10);  // 长度为10的buffer，初始值不确定

var buf4 = Buffer.from([1, 2, 3])  // 长度为3的buffer，初始值为 0x01, 0x02, 0x03

By Buffer.from()

Beispiel 1: Buffer.from(ar ray)

// [0x62, 0x75, 0x66, 0x66, 0x65, 0x72] 为字符串 "buffer" 
// 0x62 为16进制，转成十进制就是 98，代表的就是字母 b
var buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
console.log(buf.toString());

Beispiel 2: Buffer.from(string[,kodierung])

Erstellen Sie einen Puffer durch einen String. Denken Sie beim Konvertieren des Puffers in einen String daran, die Kodierung konsistent zu halten, da sonst verstümmelte Zeichen angezeigt werden, wie unten gezeigt.

var buf = Buffer.from('this is a tést');  // 默认采用utf8

// 输出：this is a tést
console.log(buf.toString());  // 默认编码是utf8，所以正常打印

// 输出：this is a tC)st
console.log(buf.toString('ascii'));  // 转成字符串时，编码不是utf8，所以乱码

Die Analyse verstümmelter Zeichen lautet wie folgt:

var letter = 'é';
var buff = Buffer.from(letter);  // 默认编码是utf8，这里占据两个字节 <Buffer c3 a9>
var len = buff.length;  // 2
var code = buff[0]; // 第一个字节为0xc3，即195：超出ascii的最大支持范围
var binary = code.toString(2);  // 195的二进制：10101001
var finalBinary = binary.slice(1);  // 将高位的1舍弃，变成：0101001
var finalCode = parseInt(finalBinary, 2);  // 0101001 对应的十进制：67
var finalLetter = String.fromCharCode(finalCode);  // 67对应的字符：C

// 同理 0xa9最终转成的ascii字符为)
// 所以，最终输出为 this is a tC)st

Beispiel 3: Buffer.from(buffer)

Erstellen Sie eine neue Buffer-Instanz und kopieren Sie die Pufferdaten in die neue Instanz.

var buff = Buffer.from('buffer');
var buff2 = Buffer.from(buff);

console.log(buff.toString());  // 输出：buffer
console.log(buff2.toString());  // 输出：buffer

buff2[0] = 0x61;

console.log(buff.toString());  // 输出：buffer
console.log(buff2.toString());  // 输出：auffer

Puffervergleich

buf.equals(otherBuffer)

bestimmt, ob die in zwei Pufferinstanzen gespeicherten Daten gleich sind. Wenn ja, wird true zurückgegeben, andernfalls wird false zurückgegeben.

// 例子一：编码一样，内容相同
var buf1 = Buffer.from('A');
var buf2 = Buffer.from('A');

console.log( buf1.equals(buf2) );  // true

// 例子二：编码一样，内容不同
var buf3 = Buffer.from('A');
var buf4 = Buffer.from('B');

console.log( buf3.equals(buf4) );  // false

// 例子三：编码不一样，内容相同
var buf5 = Buffer.from(&#39;ABC&#39;);  // <Buffer 41 42 43>
var buf6 = Buffer.from(&#39;414243&#39;, &#39;hex&#39;);

console.log(buf5.equals(buf6));    //true

//只要比较的两者内容相同,`buf.equals(otherBuffer)` 就返回true

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

vergleicht auch zwei Pufferinstanzen, der Unterschied ist:

• Sie können einen bestimmten Vergleich angeben Bereich (angegeben durch Start und Ende)

• Der Rückgabewert ist eine Ganzzahl, und das Größenverhältnis zwischen buf und Ziel erreicht den Standard

Angenommen, der Rückgabewert ist

• 0</code >: buf, Zielgröße gleich. <code>0：buf、target大小相同。
• 1：buf大于target，也就是说buf应该排在target之后。
• -1：buf小于target，也就是说buf应该排在target之前。

看例子，官方的例子挺好的，直接贴一下：

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

// Prints: 0
console.log(buf1.compare(buf1));

// Prints: -1
console.log(buf1.compare(buf2));

// Prints: -1
console.log(buf1.compare(buf3));

// Prints: 1
console.log(buf2.compare(buf1));

// Prints: 1
console.log(buf2.compare(buf3));

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

Buffer.compare(buf1, buf2)

跟 buf.compare(target) 大同小异，一般用于排序。直接贴官方例子：

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

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

从Buffer.from([62])谈起

这里稍微研究下Buffer.from(array)。下面是官方文档对API的说明，也就是说，每个array的元素对应1个字节（8位），取值从0到255。

Allocates a new Buffer using an array of octets.

数组元素为数字

首先看下，传入的元素为数字的场景。下面分别是10进制、8进制、16进制，跟预期中的结果一致。

var buff = Buffer.from([62])
// <Buffer 3e>
// buff[0] === parseInt(&#39;3e&#39;, 16) === 62

var buff = Buffer.from([062])
// <Buffer 32>
// buff[0] === parseInt(62, 8) === parseInt(32, 16) === 50

var buff = Buffer.from([0x62])
// <Buffer 62>
// buff[0] === parseInt(62, 16) === 98

数组元素为字符串

再看下，传入的元素为字符串的场景。

• 0开头的字符串，在parseInt('062')时，可以解释为62，也可以解释为50（八进制），这里看到采用了第一种解释。

• 字符串的场景，跟parseInt()有没有关系，暂未深入探究，只是这样猜想。TODO（找时间研究下）

var buff = Buffer.from(['62'])
// <Buffer 3e>
// buff[0] === parseInt(&#39;3e&#39;, 16) === parseInt(&#39;62&#39;) === 62

var buff = Buffer.from(['062'])
// <Buffer 3e>
// buff[0] === parseInt(&#39;3e&#39;, 16) === parseInt(&#39;062&#39;) === 62

var buff = Buffer.from(['0x62'])
// <Buffer 62>
// buff[0] === parseInt(&#39;62&#39;, 16) === parseInt(&#39;0x62&#39;) === 98

数组元素大小超出1个字节

感兴趣的同学自行探究。

var buff = Buffer.from([256])
// <Buffer 00>

Buffer.from('1')

一开始不自觉的会将Buffer.from('1')[0]跟"1"划等号，其实"1"对应的编码是49。

var buff = Buffer.from(&#39;1&#39;)  // <Buffer 31>
console.log(buff[0] === 1)  // false

这样对比就知道了，编码为1的是个控制字符，表示 Start of Heading。

console.log( String.fromCharCode(49) )  // '1'
console.log( String.fromCharCode(1) )  // '\u0001'

buffer连接：Buffer.concat(list[, totalLength])

备注：个人觉得totalLength

1: buf ist größer als das Ziel, was bedeutet, dass buf nach dem Ziel eingestuft werden sollte.

-1: buf ist kleiner als das Ziel, was bedeutet, dass buf vor dem Ziel eingestuft werden sollte. 🎜🎜🎜Schauen Sie sich das Beispiel an, das offizielle Beispiel ist ziemlich gut, fügen Sie es einfach ein: 🎜

var buff1 = Buffer.alloc(10);
var buff2 = Buffer.alloc(20);

var totalLength = buff1.length + buff2.length;

console.log(totalLength);  // 30

var buff3 = Buffer.concat([buff1, buff2], totalLength);

console.log(buff3.length);  // 30

🎜Buffer.compare(buf1, buf2)🎜🎜🎜with buf .compare (target) ist ähnlich und wird im Allgemeinen zum Sortieren verwendet. Posten Sie das offizielle Beispiel direkt: 🎜

var buff4 = Buffer.from([1, 2]);
var buff5 = Buffer.from([3, 4]);

var buff6 = Buffer.concat([buff4, buff5], 5);

console.log(buff6.length);  // 
console.log(buff6);  // <Buffer 01 02 03 04 00>

var buff7 = Buffer.concat([buff4, buff5], 3);

console.log(buff7.length);  // 3
console.log(buff7);  // <Buffer 01 02 03>

🎜Beginnen wir mit Buffer.from([62])🎜🎜🎜Lassen Sie uns Buffer.from(array) hier ein wenig studieren. Das Folgende ist die Beschreibung der API im offiziellen Dokument. Das heißt, jedes Array-Element entspricht 1 Byte (8 Bit) und der Wert reicht von 0 bis 255. 🎜

🎜Ordnet einen neuen Puffer mithilfe eines Arrays von Oktetten zu.🎜

🎜Die Array-Elemente sind Zahlen🎜🎜🎜Auf den ersten Blick sind die eingehenden Elemente Zahlenszene . Die folgenden sind dezimal, oktal und hexadezimal, was mit den erwarteten Ergebnissen übereinstimmt. 🎜

var buff1 = Buffer.from([1, 2]);
var buff2 = Buffer.alloc(2);

buff1.copy(buff2);

console.log(buff2);  // <Buffer 01 02>

const buf1 = Buffer.allocUnsafe(26);
const buf2 = Buffer.allocUnsafe(26).fill('!');

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

buf1.copy(buf2, 8, 16, 20);

// Prints: !!!!!!!!qrst!!!!!!!!!!!!!
console.log(buf2.toString(&#39;ascii&#39;, 0, 25));

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

// Prints: 0
console.log(buf.indexOf('this'));

// Prints: 2
console.log(buf.indexOf('is'));

// Prints: 8
console.log(buf.indexOf(Buffer.from('a buffer')));

// Prints: 8
// (97 is the decimal ASCII value for 'a')
console.log(buf.indexOf(97));

// Prints: -1
console.log(buf.indexOf(Buffer.from('a buffer example')));

// Prints: 8
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));


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

// Prints: 4
console.log(utf16Buffer.indexOf('\u03a3', 0, 'ucs2'));

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

🎜Das Array-Element ist ein String🎜🎜🎜Sehen wir uns das Szenario an, in dem das eingehende Element ein String ist. 🎜🎜🎜🎜Die Zeichenfolge, die mit 0 beginnt, kann als 62 oder 50 (oktal) interpretiert werden, wenn parseInt('062') verwendet wird. Hier sehen wir, dass die erste Interpretation verwendet wird. 🎜🎜🎜🎜Ob das String-Szenario etwas mit parseInt() zu tun hat, wurde noch nicht eingehend untersucht, sondern ist nur eine Vermutung. TODO (Zeit zum Lernen finden)🎜🎜🎜

var buff = Buffer.alloc(4);
buff.write('a');  // 返回 1
console.log(buff);  // 打印 <Buffer 61 00 00 00>

buff.write(&#39;ab&#39;);  // 返回 2
console.log(buff);  // 打印 <Buffer 61 62 00 00>

var buff = Buffer.alloc(20).fill('a');

console.log(buff.toString());  // aaaaaaaaaaaaaaaaaaaa

var buff = Buffer.from('hello');

console.log( buff.toString() );  // hello

console.log( buff.toString('utf8', 0, 2) );  // he

🎜Die Größe des Array-Elements überschreitet 1 Byte🎜🎜🎜Interessierte Schüler können es auf eigene Faust erkunden. 🎜

var buff = Buffer.from('hello');

console.log( buff.toJSON() );  // { type: 'Buffer', data: [ 104, 101, 108, 108, 111 ] }

🎜Buffer.from('1')🎜🎜🎜Unbewusst, Buffer.from('1')[0]Gleichheitszeichen mit < code>"1" Tatsächlich ist der entsprechende Code von "1" 49. 🎜

var buff = Buffer.from('abcde');

for(const key of buff.keys()){
    console.log('key is %d', key);
}
// key is 0
// key is 1
// key is 2
// key is 3
// key is 4

for(const value of buff.values()){
    console.log('value is %d', value);
}
// value is 97
// value is 98
// value is 99
// value is 100
// value is 101

for(const pair of buff.entries()){
    console.log('buff[%d] === %d', pair[0], pair[1]);
}
// buff[0] === 97
// buff[1] === 98
// buff[2] === 99
// buff[3] === 100
// buff[4] === 101

🎜Aus diesem Vergleich wissen Sie, dass der Code 1 ein Steuerzeichen ist, was Start of Heading bedeutet. 🎜

var buff1 = Buffer.from('abcde');
console.log(buff1);  // <Buffer 61 62 63 64 65>

var buff2 = buff1.slice();
console.log(buff2);  // <Buffer 61 62 63 64 65>

var buff3 = buff1.slice(1, 3);
console.log(buff3);  // <Buffer 62 63>

buff3[0] = 97;  // parseInt(61, 16) ==> 97
console.log(buff1);  // <Buffer 62 63>

🎜Pufferverbindung: Buffer.concat(list[, totalLength])🎜🎜🎜Hinweis: Ich persönlich halte den Parameter totalLength für ziemlich überflüssig Laut offizieller Dokumentation wird dies unter dem Gesichtspunkt der Leistungsverbesserung betrachtet. Die interne Implementierung durchläuft jedoch nur die Liste und akkumuliert die Länge, um totalLength zu erhalten. Unter diesem Gesichtspunkt ist die Leistungsoptimierung nahezu vernachlässigbar. 🎜rrreee🎜Neben der oben erwähnten Leistungsoptimierung gibt es noch zwei weitere Punkte zu totalLength zu beachten. Gehen Sie davon aus, dass die kumulative Länge aller Puffer in der Liste length🎜 ist

• totalLength > length：返回长度为totalLength的Buffer实例，超出长度的部分填充0。
• totalLength < length：返回长度为totalLength的Buffer实例，后面部分舍弃。

var buff4 = Buffer.from([1, 2]);
var buff5 = Buffer.from([3, 4]);

var buff6 = Buffer.concat([buff4, buff5], 5);

console.log(buff6.length);  // 
console.log(buff6);  // <Buffer 01 02 03 04 00>

var buff7 = Buffer.concat([buff4, buff5], 3);

console.log(buff7.length);  // 3
console.log(buff7);  // <Buffer 01 02 03>

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

使用比较简单，如果忽略后面三个参数，那就是将buf的数据拷贝到target里去，如下所示：

var buff1 = Buffer.from([1, 2]);
var buff2 = Buffer.alloc(2);

buff1.copy(buff2);

console.log(buff2);  // <Buffer 01 02>

另外三个参数比较直观，直接看官方例子

const buf1 = Buffer.allocUnsafe(26);
const buf2 = Buffer.allocUnsafe(26).fill('!');

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

buf1.copy(buf2, 8, 16, 20);

// Prints: !!!!!!!!qrst!!!!!!!!!!!!!
console.log(buf2.toString(&#39;ascii&#39;, 0, 25));

查找：buf.indexOf(value[, byteOffset][, encoding])

跟数组的查找差不多，需要注意的是，value可能是String、Buffer、Integer中的任意类型。

• String：如果是字符串，那么encoding就是其对应的编码，默认是utf8。
• Buffer：如果是Buffer实例，那么会将value中的完整数据，跟buf进行对比。
• Integer：如果是数字，那么value会被当做无符号的8位整数，取值范围是0到255。

另外，可以通过byteOffset来指定起始查找位置。

直接上代码，官方例子妥妥的，耐心看完它基本就理解得差不多了。

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

// Prints: 0
console.log(buf.indexOf('this'));

// Prints: 2
console.log(buf.indexOf('is'));

// Prints: 8
console.log(buf.indexOf(Buffer.from('a buffer')));

// Prints: 8
// (97 is the decimal ASCII value for 'a')
console.log(buf.indexOf(97));

// Prints: -1
console.log(buf.indexOf(Buffer.from('a buffer example')));

// Prints: 8
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));


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

// Prints: 4
console.log(utf16Buffer.indexOf('\u03a3', 0, 'ucs2'));

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

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

将sring写入buf实例，同时返回写入的字节数。

参数如下：

• string：写入的字符串。
• offset：从buf的第几位开始写入，默认是0。
• length：写入多少个字节，默认是 buf.length - offset。
• encoding：字符串的编码，默认是utf8。

看个简单例子

var buff = Buffer.alloc(4);
buff.write('a');  // 返回 1
console.log(buff);  // 打印 <Buffer 61 00 00 00>

buff.write(&#39;ab&#39;);  // 返回 2
console.log(buff);  // 打印 <Buffer 61 62 00 00>

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

用value填充buf，常用于初始化buf。参数说明如下：

• value：用来填充的内容，可以是Buffer、String或Integer。
• offset：从第几位开始填充，默认是0。
• end：停止填充的位置，默认是 buf.length。
• encoding：如果value是String，那么为value的编码，默认是utf8。

例子：

var buff = Buffer.alloc(20).fill('a');

console.log(buff.toString());  // aaaaaaaaaaaaaaaaaaaa

转成字符串: buf.toString([encoding[, start[, end]]])

把buf解码成字符串，用法比较直观，看例子

var buff = Buffer.from('hello');

console.log( buff.toString() );  // hello

console.log( buff.toString('utf8', 0, 2) );  // he

转成JSON字符串：buf.toJSON()

var buff = Buffer.from('hello');

console.log( buff.toJSON() );  // { type: 'Buffer', data: [ 104, 101, 108, 108, 111 ] }

遍历：buf.values()、buf.keys()、buf.entries()

用于对buf进行for...of遍历，直接看例子。

var buff = Buffer.from('abcde');

for(const key of buff.keys()){
    console.log('key is %d', key);
}
// key is 0
// key is 1
// key is 2
// key is 3
// key is 4

for(const value of buff.values()){
    console.log('value is %d', value);
}
// value is 97
// value is 98
// value is 99
// value is 100
// value is 101

for(const pair of buff.entries()){
    console.log('buff[%d] === %d', pair[0], pair[1]);
}
// buff[0] === 97
// buff[1] === 98
// buff[2] === 99
// buff[3] === 100
// buff[4] === 101

截取：buf.slice([start[, end]])

用于截取buf，并返回一个新的Buffer实例。需要注意的是，这里返回的Buffer实例，指向的仍然是buf的内存地址，所以对新Buffer实例的修改，也会影响到buf。

var buff1 = Buffer.from('abcde');
console.log(buff1);  // <Buffer 61 62 63 64 65>

var buff2 = buff1.slice();
console.log(buff2);  // <Buffer 61 62 63 64 65>

var buff3 = buff1.slice(1, 3);
console.log(buff3);  // <Buffer 62 63>

buff3[0] = 97;  // parseInt(61, 16) ==> 97
console.log(buff1);  // <Buffer 62 63>

TODO

• 创建、拷贝、截取、转换、查找

• buffer、arraybuffer、dataview、typedarray

• buffer vs 编码

• Buffer.from()、Buffer.alloc()、Buffer.alocUnsafe()

• Buffer vs TypedArray

文档摘要

关于buffer内存空间的动态分配

Instances of the Buffer class are similar to arrays of integers but correspond to fixed-sized, raw memory allocations outside the V8 heap. The size of the Buffer is established when it is created and cannot be resized.

相关链接

unicode对照表 https://unicode-table.com/cn/#control-character

字符编码笔记：ASCII，Unicode和UTF-8 http://www.ruanyifeng.com/blog/2007/10/ascii_unicode_and_utf-8.html

更多编程相关知识，请访问：编程视频！！

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung gängiger APIs des Nodejs-Puffermoduls. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!