NodeJSのバイナリバッファオブジェクトインスタンスの詳細説明

前の言葉

ES6 で TypedArray が導入されるまで、JavaScript 言語にはバイナリ データ ストリームを読み取ったり操作したりするメカニズムがありませんでした。 Buffer クラスは Nodejs API の一部として導入され、TCP ストリーミングやファイル システム操作などのシナリオでバイナリ データ ストリームを処理できるようになります。 TypedArray が ES6 に追加されたため、Buffer クラスは Node.js のユースケースに適した方法で Uint8Array を実装します。この記事では、バッファオブジェクトについて詳しく紹介します

概要

さまざまなアプリケーションシナリオのため、Nodeでは、アプリケーションはネットワークプロトコルの処理、データベースの操作、画像の処理、アップロードされたファイルの受信などを行う必要があります。大量のバイナリデータを処理するには、JavaScript 独自の文字列ではこれらのニーズを満たすことができないため、Buffer オブジェクトが登場しました。これは、JavaScript と C++ を組み合わせた典型的なモジュールです。パフォーマンスに関連する部分は C++ に変換され、パフォーマンスに関係しない部分は JavaScript で実装されます。 Buffer クラスのインスタンスは整数配列に似ていますが、サイズが固定されていて、物理メモリが V8 ヒープの外部に割り当てられる点が異なります。バッファのサイズは作成時に決定され、サイズを変更することはできません

バッファは非常に一般的なため、ノードはプロセスの開始時にそれをロードし、グローバルオブジェクト（グローバル）に配置します。そのため、Buffer を使用する場合、requirement() を使用せずに直接使用できます。 コンストラクターによって作成され、指定されたパラメーターに従ってさまざまなバッファーが返され、nodejs の新しいバージョンでは対応するメソッド

1. new Buffer(size) が提供されます。 Buffer() に最初のパラメータとして値を渡し( new Buffer(10) など)、指定したサイズの新しい Buffer オブジェクトを割り当てます

この Buffer インスタンスに割り当てられたメモリは初期化されていません ( 0 で埋められていません)。この設計によりメモリ割り当てが非常に高速になりますが、割り当てられたメモリ セグメントには機密性の高い古いデータが含まれる可能性があります。このバッファ インスタンスは、buf.fill(0) を使用するか、バッファを埋めることによって手動で初期化する必要があります。この動作はパフォーマンスを向上させるための意図的なものですが、開発経験から、高速だが初期化されていないバッファの作成と、低速だが安全なバッファの作成とをより明確に区別する必要があることがわかっています

/*{ [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);

[注] Buffer オブジェクトにスペースを割り当てる場合、長さは固定されており、変更できません

var buf = new Buffer(5);
console.log(buf);//<buffer>buf.fill(0);
console.log(buf);//<buffer></buffer></buffer>

Buffer实例是通过Buffer构造函数创建的，它根据提供的参数返回不同的 Buffer，而新版本的nodejs则提供了对应的方法

　　1、new Buffer(size)。传一个数值作为第一个参数给Buffer()(如new Buffer(10))，则分配一个指定大小的新建的Buffer对象

　　分配给这种Buffer实例的内存是未初始化的(没有用0填充)。虽然这样的设计使得内存的分配非常快，但已分配的内存段可能包含潜在的敏感旧数据

　　这种Buffer实例必须手动地被初始化，可以使用buf.fill(0)或写满这个Buffer。虽然这种行为是为了提高性能而有意为之的，但开发经验表明，创建一个快速但未初始化的Buffer与创建一个慢点但更安全的Buffer之间需要有更明确的区分

var buf = new Buffer(5);
console.log(buf);//<buffer>buf[0] = 1;
console.log(buf);//<buffer>buf[10] = 1;
console.log(buf);//<buffer></buffer></buffer></buffer>

　　[注意]当我们为一个Buffer对象分配空间大小后，其长度就是固定的，不能更改

var buf = Buffer.allocUnsafe(10);
console.log(buf);//<buffer>buf.fill(0);
console.log(buf);//<buffer></buffer></buffer>

　　【Buffer.allocUnsafe(size)】

 　　在新版本中，由Buffer.allocUnsafe(size)方法替代，来分配一个大小为 size 字节的新建的没有用0填充的Buffer。可以使用buf.fill(0)初始化Buffer

【Buffer.allocUnsafe(size)】

新しいバージョンでは、Buffer.allocUnsafe(size) メソッドの代わりに、サイズが 0 で埋められていない新しいバッファを割り当てます。 size バイト。 buf.fill(0) を使用して、Buffer インスタンスを 0

var buf = Buffer.alloc(5);
console.log(buf);//<buffer></buffer>

【Buffer.alloc(size[, fill[, encoding]]) に初期化できます。 】

新しいバージョンでは、Buffer.alloc(size) メソッドを使用して、新しい Buffer の予想される長さを生成します。 | は、新しく作成されたバッファの値を事前に入力するために使用されます。 デフォルト: 0; エンコーディング fill が文字列の場合、この値はその文字エンコーディングです。 デフォルト: 'utf8'

size バイトの新しい Buffer を割り当てます。 fill が定義されていない場合、Buffer は 0

var buf1 = new Buffer([1, 2, 3, 4, 5]);
console.log(buf1);//<buffer>var buf2 = new Buffer(buf1);
console.log(buf2);//<buffer></buffer></buffer>

2. 新しい Buffer (配列またはバッファ) で埋められます。第一引数として配列またはBufferを渡し、渡されたオブジェクトのデータをBufferにコピーします

var buf1 = Buffer.from([1, 2, 3, 4, 5]);
console.log(buf1);//<buffer>var buf2 = Buffer.from(buf1);
console.log(buf2);//<buffer></buffer></buffer>

【Buffer.from(array orbuffer)】

新バージョンでは、 Buffer.from(array orbuffer )

var buf1 = new Buffer('this is a tést');
console.log(buf1.toString());//this is a téstconsole.log(buf1.toString('ascii'));//this is a tC)stvar buf2 = new Buffer('7468697320697320612074c3a97374', 'hex');
console.log(buf2.toString());//this is a tést

の代わりのメソッド 3. new Buffer(string[, encoding])。最初のパラメータは文字列で、2 番目のパラメータはエンコード方式です。デフォルトは 'utf-8' です

'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' - 将每个字节编码为两个十六进制字符。

現在 Node.js でサポートされている文字エンコーディングは次のとおりです。

var buf1 = Buffer.from('this is a tést');
console.log(buf1.toString());//this is a téstconsole.log(buf1.toString('ascii'));//this is a tC)stvar buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');
console.log(buf2.toString());//this is a tést

【Buffer.from( string[,encoding])]

新バージョンではBuffer.from(string[,encoding]メソッド

var arr = new Uint16Array(2);
arr[0] = 5000;
arr[1] = 4000;var buf = new Buffer(arr.buffer);
console.log(buf);//<buffer>arr[1] = 6000;
console.log(buf);//<buffer></buffer></buffer>

4. new Buffer(arrayBuffer[, byteOffset [, length]])に置き換えられています。パラメータ arrayBuffer ArrayBuffer、または TypedArray の .buffer プロパティ; byteOffset デフォルトは 0 です。 length - byteOffset

var arr = new Uint16Array(2);
arr[0] = 5000;
arr[1] = 4000;var buf = Buffer.from(arr.buffer);
console.log(buf);//<buffer>arr[1] = 6000;
console.log(buf);//<buffer></buffer></buffer>

Buffer.from(arrayBuffer[, byteOffset [, length]])]

新しいバージョンでは、Buffer.from(arrayBuffer[, byteOffset [, length]]) メソッドに置き換えられます。

console.log(Buffer.from('test'));//<buffer></buffer>

class array

Bufferオブジェクトは配列に似ており、その要素は2桁の16進数、つまり0から255までの値です🎜🎜

var buf = Buffer.from('match');
console.log(buf.length);//5var buf = Buffer.from('火柴');
console.log(buf.length);//6

🎜

【长度】

　　不同编码的字符串占用的元素个数各不相同，中文字在UTF-8编码下占用3个元素，字母和半角标点符号占用1个元素

var buf = Buffer.from('match');
console.log(buf.length);//5var 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]); // 156buf[1] = 300;
console.log(buf[1]); // 44buf[2] = 3.1415;
console.log(buf[2]); // 3

【fromcharcode】

　　通常地，创建的buffer对象的内容是其uft-8字符编码

var buf = Buffer.from('match'); 
console.log(buf); //<buffer></buffer>

　　如果要访问其对应的字符，则需要使用字符串的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 

　　同时当前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 onethis.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 要写入 buf 的字符串

　　offset 开始写入 string 的位置。默认: 0

　　length 要写入的字节数。默认: buf.length - offset

　　encoding string 的字符编码。默认: 'utf8'；返回: 写入的字节数

　　根据 encoding 的字符编码写入 string 到 buf 中的 offset 位置。 length 参数是写入的字节数。 如果 buf 没有足够的空间保存整个字符串，则只会写入 string 的一部分。 只部分解码的字符不会被写入

var buf = Buffer.alloc(5); 
console.log(buf); //<buffer>var len = buf.write('test',1,3);
console.log(buf);//<buffer>console.log(len);/3</buffer></buffer>

　　由于可以不断写入内容到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 

【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'));//trueconsole.log(Buffer.isEncoding('gbk'));//false

 

类方法

【Buffer.byteLength(string[, encoding])】

　　Buffer.byteLength()方法返回一个字符串的实际字节长度。 这与 String.prototype.length 不同，因为那返回字符串的字符数

　　string | | | | 要计算长度的值

　　encoding 如果 string 是字符串，则这是它的字符编码。 默认: 'utf8'

　　返回: string 包含的字节数

var str = '火柴';var buf = Buffer.from(str);
console.log(str.length);//2console.log(buf.length);//6console.log(buf.byteLength);//6

【Buffer.compare(buf1, buf2)】

　　该方法用于比较 buf1 和 buf2 ，通常用于 Buffer 实例数组的排序。 相当于调用 buf1.compare(buf2) 

　　buf1

　　buf2

　　Returns:

var buf1 = Buffer.from('1234');var buf2 = Buffer.from('0123');var arr = [buf1, buf2];var result = Buffer.compare(buf1,buf2);
console.log(result);//1console.log(arr.sort());//[ <buffer>, <buffer> ]</buffer></buffer>

【Buffer.concat(list[, totalLength])】

　　该方法返回一个合并了 list 中所有 Buffer 实例的新建的 Buffer

　　list 要合并的 Buffer 实例的数组

　　totalLength 合并时 list 中 Buffer 实例的总长度

　　返回:

　　如果 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);//42var bufA = Buffer.concat([buf1, buf2, buf3], totalLength); 
console.log(bufA);//<buffer>console.log(bufA.length);//42</buffer>

【Buffer.isBuffer(obj)】

　　如果 obj 是一个 Buffer 则返回 true ，否则返回 false

var buf = Buffer.alloc(5);var str = 'test';
console.log(Buffer.isBuffer(buf));//trueconsole.log(Buffer.isBuffer(str));//false

 

实例方法

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

　　该方法返回一个指向相同原始内存的新建的 Buffer，但做了偏移且通过 start 和 end 索引进行裁剪

　　start 新建的 Buffer 开始的位置。 默认: 0

　　end 新建的 Buffer 结束的位置（不包含）。 默认: buf.length

　　返回:

var buffer1 =Buffer.from('test');
console.log(buffer1);//<buffer>var buffer2 = buffer1.slice(1,3);
console.log(buffer2);//<buffer>console.log(buffer2.toString());//'es'</buffer></buffer>

　　[注意]修改这个新建的 Buffer 切片，也会同时修改原始的 Buffer 的内存，因为这两个对象所分配的内存是重叠的

var buffer1 =Buffer.from('test');
console.log(buffer1);//<buffer>var buffer2 = buffer1.slice(1,3);
console.log(buffer2);//<buffer>buffer2[0] = 0;
console.log(buffer1);//<buffer>console.log(buffer2);//<buffer></buffer></buffer></buffer></buffer>

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

　　该方法用于拷贝 buf 的一个区域的数据到 target 的一个区域，即便 target 的内存区域与 buf 的重叠

　　target | 要拷贝进的 Buffer 或 Uint8Array

　　targetStart target 中开始拷贝进的偏移量。 默认: 0

　　sourceStart buf 中开始拷贝的偏移量。 当 targetStart 为 undefined 时忽略。 默认: 0

　　sourceEnd buf 中结束拷贝的偏移量（不包含）。 当 sourceStart 为 undefined 时忽略。 默认: buf.length

　　返回: 被拷贝的字节数

var buffer1 =Buffer.from('test');var buffer2 = Buffer.alloc(5);var len = buffer1.copy(buffer2,1,3);
console.log(buffer1);//<buffer>console.log(buffer2);//<buffer>console.log(len);//1</buffer></buffer>

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

　　该方法比较 buf 与 target，返回表明 buf 在排序上是否排在 target 之前、或之后、或相同。 对比是基于各自 Buffer 实际的字节序列

　　target 要比较的 Buffer

　　targetStart target 中开始对比的偏移量。 默认: 0

　　targetEnd target 中结束对比的偏移量（不包含）。 当 targetStart 为 undefined 时忽略。 默认: target.length

　　sourceStart buf 中开始对比的偏移量。 当 targetStart 为 undefined 时忽略。 默认: 0

　　sourceEnd buf 中结束对比的偏移量（不包含）。 当 targetStart 为 undefined 时忽略。 默认: buf.length

　　返回:

　　如果 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 要比较的 Buffer

　　返回:

var buf1 = Buffer.from('ABC');var buf2 = Buffer.from('ABC');var buf3 = Buffer.from('abc');
console.log(buf1.equals(buf2));//trueconsole.log(buf1.equals(buf3));//false

【buf.fill(value[, offset[, end]][, encoding])】

　　value | | 用来填充 buf 的值

　　offset 开始填充 buf 的位置。默认: 0

　　end 结束填充 buf 的位置（不包含）。默认: buf.length

　　encoding 如果 value 是一个字符串，则这是它的字符编码。 默认: 'utf8'

　　返回: buf 的引用

　　如果未指定 offset 和 end，则填充整个 buf。 这个简化使得一个Buffer的创建与填充可以在一行内完成

var b = Buffer.allocUnsafe(10).fill('h');
console.log(b.toString());//hhhhhhhhhh

【buf.indexOf(value[, byteOffset][, encoding])】

　　value | | 要搜索的值

　　byteOffset buf 中开始搜索的位置。默认: 0

　　encoding 如果 value 是一个字符串，则这是它的字符编码。 默认: 'utf8'

　　返回: 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');// 输出: 0console.log(buf.indexOf('this'));// 输出: 2console.log(buf.indexOf('is'));// 输出: 8console.log(buf.indexOf(Buffer.from('a buffer')));// 输出: 8// (97 是 'a' 的十进制 ASCII 值)console.log(buf.indexOf(97));// 输出: -1console.log(buf.indexOf(Buffer.from('a buffer example')));// 输出: 8console.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');// 输出: 0console.log(buf.lastIndexOf('this'));// 输出: 17console.log(buf.lastIndexOf('buffer'));// 输出: 17console.log(buf.lastIndexOf(Buffer.from('buffer')));// 输出: 15// (97 是 'a' 的十进制 ASCII 值)console.log(buf.lastIndexOf(97));// 输出: -1console.log(buf.lastIndexOf(Buffer.from('yolo')));// 输出: 5console.log(buf.lastIndexOf('buffer', 5));// 输出: -1console.log(buf.lastIndexOf('buffer', 4));

【buf.includes(value[, byteOffset][, encoding])】

　　该方法相当于 buf.indexOf() !== -1

　　value | | 要搜索的值

　　byteOffset buf 中开始搜索的位置。默认: 0

　　encoding 如果 value 是一个字符串，则这是它的字符编码。 默认: 'utf8'

　　返回: 如果 buf 找到 value，则返回 true，否则返回 false

var buf = Buffer.from('this is a buffer');// 输出: trueconsole.log(buf.includes('this'));// 输出: trueconsole.log(buf.includes('is'));// 输出: trueconsole.log(buf.includes(Buffer.from('a buffer')));// 输出: true// (97 是 'a' 的十进制 ASCII 值)console.log(buf.includes(97));// 输出: falseconsole.log(buf.includes(Buffer.from('a buffer example')));// 输出: trueconsole.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));// 输出: falseconsole.log(buf.includes('this', 4));

 

以上がNodeJSのバイナリバッファオブジェクトインスタンスの詳細説明の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。