nodeJS의 바이너리 버퍼 객체에 대한 자세한 소개
- 黄舟원래의
- 2017-06-04 10:46:361095검색
이 글에서는 nodeJS의 바이너리 버퍼object를 주로 소개합니다. 편집자가 꽤 좋다고 생각해서 지금 공유하고 참고용으로 올려보겠습니다. 편집기를 따라가서 살펴보겠습니다.
이전 단어
ES6에 TypedArray가 도입되기 전에는 JavaScript 언어에 바이너리 데이터 스트림을 읽거나 작동하는 메커니즘이 없었습니다. Buffer 클래스는 Nodejs의 API의 일부로 도입되어 TCP 스트림 및 파일 시스템 작업과 같은 시나리오에서 바이너리 데이터 스트림을 처리할 수 있습니다. 이제 TypedArray가 ES6에 추가되었으므로 Buffer 클래스는 Node.js 사용 사례에 더 좋고 적합한 방식으로 Uint8Array를 구현합니다. 이 글에서는 버퍼 개체에 대해 자세히 소개합니다
개요
다양한 애플리케이션 시나리오로 인해 Node에서 애플리케이션은 네트워크 프로토콜 처리, 데이터베이스 운영, 이미지 처리, 업로드 파일 수신 등을 수행해야 합니다. , 네트워크 스트림 및 파일에서 작업 중에 많은 양의 바이너리 데이터를 처리해야 합니다. JavaScript 자체의 string은 이러한 요구를 충족시키기 어렵기 때문에 Buffer 개체가 탄생했습니다.
Buffer는 JavaScript와 C++로 구현된 성능 관련 부분과 JavaScript로 구현된 비성능 관련 부분을 결합한 C++입니다. Buffer 클래스의 인스턴스는 크기가 고정되어 있고 물리적 메모리가 V8 힙 외부에 할당된다는 점을 제외하면 integersarrays와 유사합니다. Buffer의 크기는 생성될 때 결정되며 크기를 조정할 수 없습니다
Buffer는 너무 흔하기 때문에 노드는 프로세스가 시작될 때 이를 로드하여 전역 개체(global)에 배치합니다. 따라서 Buffer를 사용할 때 require()를 전달하지 않고
/*
{ [Function: Buffer]
poolSize: 8192,
from: [Function],
alloc: [Function],
allocUnsafe: [Function],
allocUnsafeSlow: [Function],
isBuffer: [Function: isBuffer],
compare: [Function: compare],
isEncoding: [Function],
concat: [Function],
byteLength: [Function: byteLength] }
*/
console.log(Buffer);를 사용하여
을 직접 생성할 수 있습니다. Node.js v6 이전 버전에서는 Buffer 생성자를 통해 Buffer 인스턴스가 생성됩니다. 제공된 매개변수는 서로 다른 버퍼를 반환하며, 새로운 버전의 nodejs는 해당 메서드
1, new 버퍼(크기)를 제공합니다. Buffer()에 첫 번째 매개변수(예: new Buffer(10))로 값을 전달하고 지정된 크기의 새 Buffer 개체를 할당합니다
이 Buffer 인스턴스에 할당된 메모리는 초기화되지 않습니다(0으로 채워지지 않음). 이 설계로 인해 메모리 할당이 매우 빨라지지만 할당된 메모리 세그먼트에는 잠재적으로 민감한 이전 데이터가 포함될 수 있습니다. 이 버퍼 인스턴스는 buf.fill(0)을 사용하거나 버퍼를 채울 수 있습니다. 이
동작은 성능 향상을 위한 의도이지만, 개발 경험에 따르면 빠르지만 초기화되지 않은 버퍼를 만드는 것과 느리지만 더 안전한 안전한Buffer var buf = new Buffer(5);
console.log(buf);//<Buffer e0 f7 1d 01 00>
buf.fill(0);
console.log(buf);//<Buffer 00 00 00 00 00>
을 만드는 것 사이에 더 명확한 구분이 필요하다는 것을 알 수 있습니다.[참고] 공간을 할당할 때 Buffer 객체의 크기는 고정되어 있으며 변경할 수 없습니다.
var buf = new Buffer(5); console.log(buf);//<Buffer b8 36 70 01 02> buf[0] = 1; console.log(buf);//<Buffer 01 36 70 01 02> buf[10] = 1; console.log(buf);//<Buffer 01 79 43 6f 6e>[Buffer.allocUnsafe(size)]
새 버전에서는 Buffer.allocUnsafe(size ) 메소드를 사용하여 크기 바이트의 새 버퍼를 할당합니다. 0으로 채워지지 않습니다. buf.fill(0)을 사용하여 Buffer 인스턴스를 0
var buf = Buffer.allocUnsafe(10); console.log(buf);//<Buffer 75 63 74 42 79 4c 65 6e 67 74> buf.fill(0); console.log(buf);//<Buffer 00 00 00 00 00 00 00 00 00 00>【Buffer.alloc(size[, fill[, 인코딩]])】
새 버전에서는 Buffer를 사용할 수 있습니다. alloc(size) 메서드 크기 0ee8737eb190bac7d838b3c624cd7ffc는 새 버퍼 채우기 c0f559cc8d56b43654fcbe4aa9df7b4a 새 Buffer 를 미리 채우는 데 사용되는 값입니다. 기본값: 0; 인코딩 f7e83be87db5cd2d9a8a0b8117b38cd4 채우기가 문자열인 경우 이 값은 문자 인코딩입니다. 기본값: 'utf8'
바이트 크기의 새 버퍼를 할당합니다. 채우기가 정의되지 않은 경우 버퍼는 0
var buf = Buffer.alloc(5); console.log(buf);//<Buffer 00 00 00 00 00>2, 새 버퍼(배열 또는 버퍼)로 채워집니다. 배열 또는 Buffer를 첫 번째 매개변수로 전달한 후 전달된 객체의 데이터를 Buffer
var buf1 = new Buffer([1, 2, 3, 4, 5]); console.log(buf1);//<Buffer 01 02 03 04 05> var buf2 = new Buffer(buf1); console.log(buf2);//<Buffer 01 02 03 04 05>
[Buffer.from(배열 또는 버퍼)]
새 버전에서는 Buffer.from(배열 또는 버퍼)에 복사합니다. ) 메소드는var buf1 = Buffer.from([1, 2, 3, 4, 5]); console.log(buf1);//<Buffer 01 02 03 04 05> var buf2 = Buffer.from(buf1); console.log(buf2);//<Buffer 01 02 03 04 05>3, new Buffer(string[, 인코딩])을 대체합니다. 첫 번째 매개변수는 문자열이고, 두 번째 매개변수는 인코딩 방식입니다. 기본값은 'utf-8'
var buf1 = new Buffer('this is a tést'); console.log(buf1.toString());//this is a tést console.log(buf1.toString('ascii'));//this is a tC)st var buf2 = new Buffer('7468697320697320612074c3a97374', 'hex'); console.log(buf2.toString());//this is a tést현재 Node.js에서 지원하는 문자 인코딩은 다음과 같습니다.
'ascii' - 仅支持 7 位 ASCII 数据。如果设置去掉高位的话，这种编码是非常快的。 'utf8' - 多字节编码的 Unicode 字符。许多网页和其他文档格式都使用 UTF-8 。 'utf16le' - 2 或 4 个字节，小字节序编码的 Unicode 字符。支持代理对（U+10000 至 U+10FFFF）。 'ucs2' - 'utf16le' 的别名。 'base64' - Base64 编码。当从字符串创建 Buffer 时，这种编码可接受“URL 与文件名安全字母表”。 'latin1' - 一种把 Buffer 编码成一字节编码的字符串的方式。 'binary' - 'latin1' 的别名。 'hex' - 将每个字节编码为两个十六进制字符。
【Buffer.from(string[, encoding])】
在新版本中，由Buffer.from(string[, encoding]方法替代
var buf1 = Buffer.from('this is a tést'); console.log(buf1.toString());//this is a tést console.log(buf1.toString('ascii'));//this is a tC)st var buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex'); console.log(buf2.toString());//this is a tést
4、new Buffer(arrayBuffer[, byteOffset [, length]])。参数arrayBuffer 17135bfb8b9af7b00f0b7172a1aa08c6 一个 ArrayBuffer，或一个 TypedArray 的 .buffer 属性；byteOffset c0f559cc8d56b43654fcbe4aa9df7b4a 开始拷贝的索引。默认为 0；length c0f559cc8d56b43654fcbe4aa9df7b4a 拷贝的字节数。默认为 arrayBuffer.length - byteOffset
var arr = new Uint16Array(2); arr[0] = 5000; arr[1] = 4000; var buf = new Buffer(arr.buffer); console.log(buf);//<Buffer 88 13 a0 0f> arr[1] = 6000; console.log(buf);//<Buffer 88 13 70 17>
【Buffer.from(arrayBuffer[, byteOffset [, length]])】
在新版本中，由Buffer.from(arrayBuffer[, byteOffset [, length]])方法替代
var arr = new Uint16Array(2); arr[0] = 5000; arr[1] = 4000; var buf = Buffer.from(arr.buffer); console.log(buf);//<Buffer 88 13 a0 0f> arr[1] = 6000; console.log(buf);//<Buffer 88 13 70 17>
类数组
Buffer对象类似于数组，它的元素为16进制的两位数，即0到255的数值
console.log(Buffer.from('test'));//<Buffer 74 65 73 74>
【长度】
不同编码的字符串占用的元素个数各不相同，中文字在UTF-8编码下占用3个元素，字母和半角标点符号占用1个元素
var buf = Buffer.from('match'); console.log(buf.length);//5 var buf = Buffer.from('火柴'); console.log(buf.length);//6
【下标】
Buffer受Array类型的影响很大，可以访问length属性得到长度，也可以通过下标访问元素
var buf = Buffer.alloc(10); console.log(buf.length); // => 10
上述代码分配了一个长10字节的Buffer对象。我们可以通过下标对它进行赋值
buf[0] = 100; console.log(buf[0]); // => 100
要注意的是，给元素的赋值如果小于0，就将该值逐次加256，直到得到一个0到255之间的整数。如果得到的数值大于255，就逐次减256，直到得到0~255区间内的数值。如果是小数，舍弃小数部分，只保留整数部分
buf[0] = -100; console.log(buf[0]); // 156 buf[1] = 300; console.log(buf[1]); // 44 buf[2] = 3.1415; console.log(buf[2]); // 3
【fromcharcode】
通常地，创建的buffer对象的内容是其uft-8字符编码
var buf = Buffer.from('match'); console.log(buf); //<Buffer 6d 61 74 63 68>
如果要访问其对应的字符，则需要使用字符串的fromCharCode()方法
console.log(String.fromCharCode(buf[0]));//'m'
内存分配
Buffer对象的内存分配不是在V8的堆内存中，而是在Node的C++层面实现内存的申请的。因为处理大量的字节数据不能采用需要一点内存就向操作系统申请一点内存的方式，这可能造成大量的内存申请的系统调用，对操作系统有一定压力。为此Node在内存的使用上应用的是在C++层面申请内存、在JavaScript中分配内存的策略
为了高效地使用申请来的内存，Node采用了slab分配机制。slab是一种动态内存管理机制，最早诞生于SunOS操作系统(Solaris)中，目前在一些*nix操作系统中有广泛的应用，如FreeBSD和Linux。简单而言，slab就是一块申请好的固定大小的内存区域。slab具有如下3种状态：full：完全分配状态；partial：部分分配状态；empty：没有被分配状态
当我们需要一个Buffer对象，可以通过以下方式分配指定大小的Buffer对象：
new Buffer(size);//旧 Buffer.alloc(size);//新
【poolSize】
poolSize属性是用于决定预分配的、内部 Buffer 实例池的大小的字节数。默认地，Node以8KB为界限来区分Buffer是大对象还是小对象：
Buffer.poolSize = 8 * 1024;
这个8KB的值也就是每个slab的大小值，在JavaScript层面，以它作为单位单元进行内存的分配
1、分配小Buffer对象
如果指定Buffer的大小少于8KB，Node会按照小对象的方式进行分配。Buffer的分配过程中主要使用一个局部变量pool作为中间处理对象，处于分配状态的slab单元都指向它。以下是分配一个全新的slab单元的操作，它会将新申请的SlowBuffer对象指向它：
var pool;
function allocPool() {
pool = new SlowBuffer(Buffer.poolSize);
pool.used = 0;
}构造小Buffer对象时的代码如下：
new Buffer(1024);//旧 Buffer.alloc(1024);//新
这次构造将会去检查pool对象，如果pool没有被创建，将会创建一个新的slab单元指向它：
if (!pool || pool.length - pool.used < this.length) allocPool();
同时当前Buffer对象的parent属性指向该slab，并记录下是从这个slab的哪个位置(offset)开始使用的，slab对象自身也记录被使用了多少字节，代码如下：
this.parent = pool; this.offset = pool.used; pool.used += this.length; if (pool.used & 7) pool.used = (pool.used + 8) & ~7;
这时候的slab状态为partial。当再次创建一个Buffer对象时，构造过程中将会判断这个slab的剩余空间是否足够。如果足够，使用剩余空间，并更新slab的分配状态。下面的代码创建了一个新的Buffer对象，它会引起一次slab分配：
new Buffer(3000);//旧 Buffer.alloc(3000);//新
如果slab剩余的空间不够，将会构造新的slab，原slab中剩余的空间会造成浪费。例如，第一次构造1字节的Buffer对象，第二次构造8192字节的Buffer对象，由于第二次分配时slab中的空间不够，所以创建并使用新的slab，第一个slab的8KB将会被第一个1字节的Buffer对象独占。下面的代码一共使用了两个slab单元：
new Buffer(1);//旧 Buffer.alloc(1);//新 new Buffer(8192);//旧 Buffer.alloc(8192);//新
要注意的是，由于同一个slab可能分配给多个Buffer对象使用，只有这些小Buffer对象在作用域释放并都可以回收时，slab的8KB空间才会被回收。尽管创建了1个字节的Buffer对象，但是如果不释放它，实际可能是8KB的内存没有释放
2、分配大Buffer对象
如果需要超过8KB的Buffer对象，将会直接分配一个SlowBuffer对象作为slab单元，这个slab单元将会被这个大Buffer对象独占
// Big buffer, just alloc one this.parent = new SlowBuffer(this.length); this.offset = 0;
这里的SlowBuffer类是在C++中定义的，虽然引用buffer模块可以访问到它，但是不推荐直接操作它，而是用Buffer替代
上面提到的Buffer对象都是JavaScript层面的，能够被V8的垃圾回收标记回收。但是其内部的parent属性指向的SlowBuffer对象却来自于Node自身C++中的定义，是C++层面上的Buffer对象，所用内存不在V8的堆中
综上，真正的内存是在Node的C++层面提供的，JavaScript层面只是使用它。当进行小而频繁的Buffer操作时，采用slab的机制进行预先申请和事后分配，使得JavaScript到操作系统之间不必有过多的内存申请方面的系统调用。对于大块的Buffer而言，则直接使用C++层面提供的内存，而无需细腻的分配操作
转换
Buffer对象可以与字符串之间相互转换。目前支持的字符串编码类型有如下几种：ASCII、UTF-8、UTF-16LE/UCS-2、Base64、Binary、Hex
【write()】
一个Buffer对象可以存储不同编码类型的字符串转码的值，调用write()方法可以实现该目的
buf.write(string, [offset], [length], [encoding])
string f7e83be87db5cd2d9a8a0b8117b38cd4 要写入 buf 的字符串
offset c0f559cc8d56b43654fcbe4aa9df7b4a 开始写入 string 的位置。默认: 0
length c0f559cc8d56b43654fcbe4aa9df7b4a 要写入的字节数。默认: buf.length - offset
encoding f7e83be87db5cd2d9a8a0b8117b38cd4 string 的字符编码。默认: 'utf8'；返回: c0f559cc8d56b43654fcbe4aa9df7b4a 写入的字节数
根据 encoding 的字符编码写入 string 到 buf 中的 offset 位置。 length 参数是写入的字节数。 如果 buf 没有足够的空间保存整个字符串，则只会写入 string 的一部分。 只部分解码的字符不会被写入
var buf = Buffer.alloc(5); console.log(buf); //<Buffer 00 00 00 00 00> var len = buf.write('test',1,3); console.log(buf);//<Buffer 00 74 65 73 00> console.log(len);/3
由于可以不断写入内容到Buffer对象中，并且每次写入可以指定编码，所以Buffer对象中可以存在多种编码转化后的内容。需要小心的是，每种编码所用的字节长度不同，将Buffer反转回字符串时需要谨慎处理
【toString()】
实现Buffer向字符串的转换也十分简单，Buffer对象的toString()可以将Buffer对象转换为字符串
buf.toString([encoding], [start], [end])
encoding - 使用的编码。默认为 'utf8'
start - 指定开始读取的索引位置，默认为 0
end - 结束位置，默认为缓冲区的末尾
返回 - 解码缓冲区数据并使用指定的编码返回字符串
var 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));//abcde
console.log( buf.toString('utf8',0,5));//abcde
console.log( buf.toString(undefined,0,5));//abcde【toJSON()】
将 Node Buffer 转换为 JSON 对象
buf.toJSON()
返回 buf 的 JSON 格式
var buf = Buffer.from('test');
var json = buf.toJSON(buf);
console.log(json);//{ type: 'Buffer', data: [ 116, 101, 115, 116 ] }【isEncoding()】
目前比较遗憾的是，Node的Buffer对象支持的编码类型有限，只有少数的几种编码类型可以在字符串和Buffer之间转换。为此，Buffer提供了一个isEncoding()函数来判断编码是否支持转换
Buffer.isEncoding(encoding)
将编码类型作为参数传入上面的函数，如果支持转换返回值为true，否则为false。很遗憾的是，在中国常用的GBK、GB2312和BIG-5编码都不在支持的行列中
console.log(Buffer.isEncoding('utf8'));//true console.log(Buffer.isEncoding('gbk'));//false
类方法
【Buffer.byteLength(string[, encoding])】
Buffer.byteLength()方法返回一个字符串的实际字节长度。 这与 String.prototype.length 不同，因为那返回字符串的字符数
string f7e83be87db5cd2d9a8a0b8117b38cd4 | 1b65c53b8ce5e15f0a761483d85cb439 | d3acf9fa6536be0f0cc4d2680165af7c | 748cdfdbba0e4c5ada8e9da1400702ac | 17135bfb8b9af7b00f0b7172a1aa08c6 要计算长度的值
encoding f7e83be87db5cd2d9a8a0b8117b38cd4 如果 string 是字符串，则这是它的字符编码。 默认: 'utf8'
返回: c0f559cc8d56b43654fcbe4aa9df7b4a string 包含的字节数
var str = '火柴'; var buf = Buffer.from(str); console.log(str.length);//2 console.log(buf.length);//6 console.log(buf.byteLength);//6
【Buffer.compare(buf1, buf2)】
该方法用于比较 buf1 和 buf2 ，通常用于 Buffer 实例数组的排序。 相当于调用 buf1.compare(buf2)
buf1 1b65c53b8ce5e15f0a761483d85cb439
buf2 1b65c53b8ce5e15f0a761483d85cb439
Returns: c0f559cc8d56b43654fcbe4aa9df7b4a
var buf1 = Buffer.from('1234'); var buf2 = Buffer.from('0123'); var arr = [buf1, buf2]; var result = Buffer.compare(buf1,buf2); console.log(result);//1 console.log(arr.sort());//[ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
【Buffer.concat(list[, totalLength])】
该方法返回一个合并了 list 中所有 Buffer 实例的新建的 Buffer
list e1db81f37932369422176d74d6ff0869 要合并的 Buffer 实例的数组
totalLength c0f559cc8d56b43654fcbe4aa9df7b4a 合并时 list 中 Buffer 实例的总长度
返回: 1b65c53b8ce5e15f0a761483d85cb439
如果 list 中没有元素、或 totalLength 为 0 ，则返回一个新建的长度为 0 的 Buffer 。如果没有提供 totalLength ，则从 list 中的 Buffer 实例计算得到。 为了计算 totalLength 会导致需要执行额外的循环，所以提供明确的长度会运行更快
var buf1 = Buffer.alloc(10); var buf2 = Buffer.alloc(14); var buf3 = Buffer.alloc(18); var totalLength = buf1.length + buf2.length + buf3.length; console.log(totalLength);//42 var bufA = Buffer.concat([buf1, buf2, buf3], totalLength); console.log(bufA);//<Buffer 00 00 00 00 ...> console.log(bufA.length);//42
【Buffer.isBuffer(obj)】
如果 obj 是一个 Buffer 则返回 true ，否则返回 false
var buf = Buffer.alloc(5); var str = 'test'; console.log(Buffer.isBuffer(buf));//true console.log(Buffer.isBuffer(str));//false
实例方法
【buf.slice([start[, end]])】
该方法返回一个指向相同原始内存的新建的 Buffer，但做了偏移且通过 start 和 end 索引进行裁剪
start c0f559cc8d56b43654fcbe4aa9df7b4a 新建的 Buffer 开始的位置。 默认: 0
end c0f559cc8d56b43654fcbe4aa9df7b4a 新建的 Buffer 结束的位置（不包含）。 默认: buf.length
返回: 1b65c53b8ce5e15f0a761483d85cb439
var buffer1 =Buffer.from('test'); console.log(buffer1);//<Buffer 74 65 73 74> var buffer2 = buffer1.slice(1,3); console.log(buffer2);//<Buffer 65 73> console.log(buffer2.toString());//'es'
[注意]修改这个新建的 Buffer 切片，也会同时修改原始的 Buffer 的内存，因为这两个对象所分配的内存是重叠的
var buffer1 =Buffer.from('test'); console.log(buffer1);//<Buffer 74 65 73 74> var buffer2 = buffer1.slice(1,3); console.log(buffer2);//<Buffer 65 73> buffer2[0] = 0; console.log(buffer1);//<Buffer 74 00 73 74> console.log(buffer2);//<Buffer 00 73>
【buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])】
该方法用于拷贝 buf 的一个区域的数据到 target 的一个区域，即便 target 的内存区域与 buf 的重叠
target 1b65c53b8ce5e15f0a761483d85cb439 | 756836fcdb8f986642d0273e1c6adad5 要拷贝进的 Buffer 或 Uint8Array
targetStart c0f559cc8d56b43654fcbe4aa9df7b4a target 中开始拷贝进的偏移量。 默认: 0
sourceStart c0f559cc8d56b43654fcbe4aa9df7b4a buf 中开始拷贝的偏移量。 当 targetStart 为 undefined 时忽略。 默认: 0
sourceEnd c0f559cc8d56b43654fcbe4aa9df7b4a buf 中结束拷贝的偏移量（不包含）。 当 sourceStart 为 undefined 时忽略。 默认: buf.length
返回: c0f559cc8d56b43654fcbe4aa9df7b4a 被拷贝的字节数
var buffer1 =Buffer.from('test'); var buffer2 = Buffer.alloc(5); var len = buffer1.copy(buffer2,1,3); console.log(buffer1);//<Buffer 74 65 73 74> console.log(buffer2);//<Buffer 00 74 00 00 00> console.log(len);//1
【buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])】
该方法比较 buf 与 target，返回表明 buf 在排序上是否排在 target 之前、或之后、或相同。 对比是基于各自 Buffer 实际的字节序列
target 1b65c53b8ce5e15f0a761483d85cb439 要比较的 Buffer
targetStart c0f559cc8d56b43654fcbe4aa9df7b4a target 中开始对比的偏移量。 默认: 0
targetEnd c0f559cc8d56b43654fcbe4aa9df7b4a target 中结束对比的偏移量（不包含）。 当 targetStart 为 undefined 时忽略。 默认: target.length
sourceStart c0f559cc8d56b43654fcbe4aa9df7b4a buf 中开始对比的偏移量。 当 targetStart 为 undefined 时忽略。 默认: 0
sourceEnd c0f559cc8d56b43654fcbe4aa9df7b4a buf 中结束对比的偏移量（不包含）。 当 targetStart 为 undefined 时忽略。 默认: buf.length
返回: c0f559cc8d56b43654fcbe4aa9df7b4a
如果 target 与 buf 相同，则返回 0
如果 target 排在 buf 前面，则返回 1
如果 target 排在 buf 后面，则返回 -1
var buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9]); var buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4]); // 输出: 0(buf2中的1234对比buf2中的1234) console.log(buf1.compare(buf2, 5, 9, 0, 4)); // 输出: -1(buf2中的567891对比buf1中的56789) console.log(buf1.compare(buf2, 0, 6, 4)); // 输出: 1(buf2中的1对比buf2中的6789) console.log(buf1.compare(buf2, 5, 6, 5));
【buf.equals(otherBuffer)】
如果 buf 与 otherBuffer 具有完全相同的字节，则返回 true，否则返回 false
otherBuffer 1b65c53b8ce5e15f0a761483d85cb439 要比较的 Buffer
返回: 558d764cdd41f624c4c5c9c8da137eab
var buf1 = Buffer.from('ABC'); var buf2 = Buffer.from('ABC'); var buf3 = Buffer.from('abc'); console.log(buf1.equals(buf2));//true console.log(buf1.equals(buf3));//false
【buf.fill(value[, offset[, end]][, encoding])】
value f7e83be87db5cd2d9a8a0b8117b38cd4 | 1b65c53b8ce5e15f0a761483d85cb439 | c0f559cc8d56b43654fcbe4aa9df7b4a 用来填充 buf 的值
offset c0f559cc8d56b43654fcbe4aa9df7b4a 开始填充 buf 的位置。默认: 0
end c0f559cc8d56b43654fcbe4aa9df7b4a 结束填充 buf 的位置（不包含）。默认: buf.length
encoding f7e83be87db5cd2d9a8a0b8117b38cd4 如果 value 是一个字符串，则这是它的字符编码。 默认: 'utf8'
返回: 1b65c53b8ce5e15f0a761483d85cb439 buf 的引用
如果未指定 offset 和 end，则填充整个 buf。 这个简化使得一个Buffer的创建与填充可以在一行内完成
var b = Buffer.allocUnsafe(10).fill('h'); console.log(b.toString());//hhhhhhhhhh
【buf.indexOf(value[, byteOffset][, encoding])】
value f7e83be87db5cd2d9a8a0b8117b38cd4 | 1b65c53b8ce5e15f0a761483d85cb439 | c0f559cc8d56b43654fcbe4aa9df7b4a 要搜索的值
byteOffset c0f559cc8d56b43654fcbe4aa9df7b4a buf 中开始搜索的位置。默认: 0
encoding f7e83be87db5cd2d9a8a0b8117b38cd4 如果 value 是一个字符串，则这是它的字符编码。 默认: 'utf8'
返回: c0f559cc8d56b43654fcbe4aa9df7b4a buf 中 value 首次出现的索引，如果 buf 没包含 value 则返回 -1
如果value是字符串，则 value 根据 encoding 的字符编码进行解析；如果value是Buffer，则value会被作为一个整体使用。如果要比较部分 Buffer 可使用 buf.slice()；如果value是数值，则 value 会解析为一个 0 至 255 之间的无符号八位整数值
var buf = Buffer.from('this is a buffer'); // 输出: 0 console.log(buf.indexOf('this')); // 输出: 2 console.log(buf.indexOf('is')); // 输出: 8 console.log(buf.indexOf(Buffer.from('a buffer'))); // 输出: 8 // (97 是 'a' 的十进制 ASCII 值) console.log(buf.indexOf(97)); // 输出: -1 console.log(buf.indexOf(Buffer.from('a buffer example'))); // 输出: 8 console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));
【buf.lastIndexOf(value[, byteOffset][, encoding])】
与 buf.indexOf() 类似，除了 buf 是从后往前搜索而不是从前往后
var buf = Buffer.from('this buffer is a buffer'); // 输出: 0 console.log(buf.lastIndexOf('this')); // 输出: 17 console.log(buf.lastIndexOf('buffer')); // 输出: 17 console.log(buf.lastIndexOf(Buffer.from('buffer'))); // 输出: 15 // (97 是 'a' 的十进制 ASCII 值) console.log(buf.lastIndexOf(97)); // 输出: -1 console.log(buf.lastIndexOf(Buffer.from('yolo'))); // 输出: 5 console.log(buf.lastIndexOf('buffer', 5)); // 输出: -1 console.log(buf.lastIndexOf('buffer', 4));
【buf.includes(value[, byteOffset][, encoding])】
该方法相当于 buf.indexOf() !== -1
value f7e83be87db5cd2d9a8a0b8117b38cd4 | 1b65c53b8ce5e15f0a761483d85cb439 | c0f559cc8d56b43654fcbe4aa9df7b4a 要搜索的值
byteOffset c0f559cc8d56b43654fcbe4aa9df7b4a buf 中开始搜索的位置。默认: 0
encoding f7e83be87db5cd2d9a8a0b8117b38cd4 如果 value 是一个字符串，则这是它的字符编码。 默认: 'utf8'
返回: 558d764cdd41f624c4c5c9c8da137eab 如果 buf 找到 value，则返回 true，否则返回 false
var buf = Buffer.from('this is a buffer'); // 输出: true console.log(buf.includes('this')); // 输出: true console.log(buf.includes('is')); // 输出: true console.log(buf.includes(Buffer.from('a buffer'))); // 输出: true // (97 是 'a' 的十进制 ASCII 值) console.log(buf.includes(97)); // 输出: false console.log(buf.includes(Buffer.from('a buffer example'))); // 输出: true console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8))); // 输出: false console.log(buf.includes('this', 4));
위 내용은 nodeJS의 바이너리 버퍼 객체에 대한 자세한 소개의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!