ホームページ > 記事 > ウェブフロントエンド > NodeJS のバイナリ バッファ オブジェクトの詳細な紹介
NodeJS のバイナリ バッファ オブジェクトの詳細な紹介
- 黄舟オリジナル
- 2017-06-04 10:46:361109ブラウズ
この記事では主にnodeJSのバイナリバッファオブジェクトを紹介していますが、編集者がとても良いと思ったので、参考として共有させていただきます。エディターに従って、見てみましょう
前の言葉
ES6 で TypedArray が導入される前は、JavaScript 言語にはバイナリ データ ストリームを読み取ったり操作したりするメカニズムがありませんでした。 Buffer クラスは Nodejs の API の一部として導入され、TCP ストリームや ファイル システム 操作などのシナリオでバイナリ データ ストリームを処理できるようにします。 TypedArray が ES6 に追加されたため、Buffer クラスは Node.js のユースケースにより適した方法で Uint8Array を実装します。この記事では、バッファ オブジェクトについて詳しく紹介します
概要
さまざまなアプリケーション シナリオのため、Node では、アプリケーションはネットワーク プロトコルの処理、データベースの操作、画像の処理、ファイルの受信アップロードなどを行う必要があります。 、ネットワークフローとファイルの動作中に大量のバイナリデータを処理する必要があるため、JavaScript 独自の string ではこれらのニーズを満たすには程遠いため、JavaScript を組み合わせた代表的なモジュールとして登場したのが Buffer です。もう 1 つは C++ で、パフォーマンスに関連する部分は C++ で実装され、パフォーマンスに関係しない部分は JavaScript で実装されます。 Buffer クラスのインスタンスは、固定サイズであることと、物理メモリが V8 ヒープの外部に割り当てられることを除いて、
整数配列と似ています。バッファのサイズは作成時に決定され、サイズを変更することはできませんバッファは非常に一般的なため、ノードはプロセスの開始時にそれをロードし、グローバルオブジェクト（グローバル）に配置します。したがって、Buffer を使用する場合、
require を直接使用して
を作成できます。Node.js v6 より前のバージョンでは、Buffer インスタンスは Buffer
を介して作成されます。提供されたパラメーターはさまざまなバッファーを返し、nodejs の新しいバージョンでは、対応するメソッド 1、
newBuffer(size) が提供されます。最初のパラメータとして値を 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.allocUnsafe(size)]新しいバージョンでは、サイズの新しいバッファを割り当てるために Buffer.allocUnsafe(size ) メソッドによって変更されます。ゼロで埋められていないバイト。 buf.fill(0) を使用して、Buffer インスタンスを 0 に初期化できます
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.alloc(size[, fill[, encoding]])】
新しいバージョンでは、Buffer が使用できるようになりました。 alloc(size) メソッド 安全なバッファ オブジェクトを生成します。 Integer> は新しいバッファの長さです。新しい Buffer を事前に埋めるために使用される値。 デフォルト: 0; エンコーディング size バイトの新しいバッファを割り当てます。 fill が定義されていない場合、バッファーは 0var 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>
2、新しいバッファー (配列またはバッファー) で埋められます。第一引数として配列またはBufferを渡し、渡されたオブジェクトのデータをBufferにコピーします
var buf = Buffer.alloc(5); console.log(buf);//<Buffer 00 00 00 00 00>
【Buffer.from(配列 or バッファ)】新バージョンでは Buffer.from(配列 or バッファ) ) メソッドは
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>
3, new Buffer(string[, encoding]) を置き換えます。最初のパラメータは文字列で、2 番目のパラメータはエンコード方式です。デフォルトは 'utf-8' です
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>
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 中国語 Web サイトの他の関連記事を参照してください。