对象 Buffer

二进制数据缓存对象，用于 io 读写的数据处理

Buffer 对象为全局基础类，在任何时候都可以直接以 new Buffer(...) 创建：

1
var buf = new Buffer();

继承关系

构造函数

Buffer

缓存对象构造函数

1
new Buffer(Array datas);

调用参数:

datas: Array, 初始化数据数组

缓存对象构造函数

1
2
3
new Buffer(ArrayBuffer datas,
    Integer byteOffset = 0,
    Integer length = -1);

调用参数:

datas: ArrayBuffer, 初始化数据数组
byteOffset: Integer, 指定数据起始位置，起始为 0
length: Integer, 指定数据长度，起始位 -1，表示剩余所有数据

缓存对象构造函数

1
2
3
new Buffer(Uint8Array datas,
    Integer byteOffset = 0,
    Integer length = -1);

调用参数:

datas: Uint8Array, 初始化数据数组
byteOffset: Integer, 指定数据起始位置，起始为 0
length: Integer, 指定数据长度，起始位 -1，表示剩余所有数据

缓存对象构造函数

1
2
new Buffer(String str,
    String codec = "utf8");

调用参数:

str: String, 初始化字符串，字符串将以 utf-8 格式写入，缺省则创建一个空对象
codec: String, 指定编码格式，允许值为："hex", "base32", "base58", "base64", "utf8", 或者 iconv 模块支持的字符集

缓存对象构造函数

1
new Buffer(Integer size = 0);

调用参数:

size: Integer, 初始化缓冲区大小

对象

二进制数据缓存对象，用于 io 读写的数据处理

1
Buffer new Buffer;

静态函数

alloc

分配一个指定长度的新缓存区。如果大小为0，将创建一个零长度的缓存区。

1
2
static Buffer Buffer.alloc(Integer size,
    Integer fill = 0);

调用参数:

size: Integer, 缓冲区的所需长度
fill: Integer, 预先填充新缓冲区的值，可使用 string/buffer/integer 值类型。默认值：0

返回结果:

Buffer, 填充好的新 Buffer 对象

分配一个指定长度的新缓存区。如果大小为0，将创建一个零长度的缓存区。

1
2
3
static Buffer Buffer.alloc(Integer size,
    String fill = "",
    String codec = "utf8");

调用参数:

size: Integer, 缓冲区的所需长度
fill: String, 预先填充新缓冲区的值，可使用 string/buffer/integer 值类型。默认值：0
codec: String, 指定编码格式，允许值为："hex", "base32", "base58", "base64", "utf8", 或者 iconv 模块支持的字符集

返回结果:

Buffer, 填充好的新 Buffer 对象

分配一个指定长度的新缓存区。如果大小为0，将创建一个零长度的缓存区。

1
2
static Buffer Buffer.alloc(Integer size,
    Buffer fill);

调用参数:

size: Integer, 缓冲区的所需长度
fill: Buffer, 预先填充新缓冲区的值，可使用 string/buffer/integer 值类型。默认值：0

返回结果:

Buffer, 填充好的新 Buffer 对象

allocUnsafe

分配一个指定长度的新缓存区。如果大小为0，将创建一个零长度的缓存区。

1
static Buffer Buffer.allocUnsafe(Integer size);

调用参数:

size: Integer, 缓冲区的所需长度

返回结果:

Buffer, 指定尺寸的新 Buffer 对象

allocUnsafeSlow

分配一个指定长度的新缓存区。如果大小为0，将创建一个零长度的缓存区。

1
static Buffer Buffer.allocUnsafeSlow(Integer size);

调用参数:

size: Integer, 缓冲区的所需长度

返回结果:

Buffer, 指定尺寸的新 Buffer 对象

from

通过给定的数组创建 Buffer 对象

1
static Buffer Buffer.from(Array datas);

调用参数:

datas: Array, 初始化数据数组

返回结果:

Buffer, 返回 Buffer 实例

通过其他 Buffer 创建 Buffer 对象

1
2
3
static Buffer Buffer.from(Buffer buffer,
    Integer byteOffset = 0,
    Integer length = -1);

调用参数:

buffer: Buffer, 给定 Buffer 类型变量用于创建 Buffer 对象
byteOffset: Integer, 指定数据起始位置，起始为 0
length: Integer, 指定数据长度，起始位 -1，表示剩余所有数据

返回结果:

Buffer, 返回 Buffer 实例

通过其他 Buffer 创建 Buffer 对象

1
2
3
static Buffer Buffer.from(ArrayBuffer datas,
    Integer byteOffset = 0,
    Integer length = -1);

调用参数:

datas: ArrayBuffer, 初始化数据数组
byteOffset: Integer, 指定数据起始位置，起始为 0
length: Integer, 指定数据长度，起始位 -1，表示剩余所有数据

返回结果:

Buffer, 返回 Buffer 实例

通过其他 Buffer 创建 Buffer 对象

1
2
3
static Buffer Buffer.from(Uint8Array datas,
    Integer byteOffset = 0,
    Integer length = -1);

调用参数:

datas: Uint8Array, 初始化数据数组
byteOffset: Integer, 指定数据起始位置，起始为 0
length: Integer, 指定数据长度，起始位 -1，表示剩余所有数据

返回结果:

Buffer, 返回 Buffer 实例

通过字符串创建 Buffer 对象

1
2
static Buffer Buffer.from(String str,
    String codec = "utf8");

调用参数:

str: String, 初始化字符串，字符串将以 utf-8 格式写入，缺省则创建一个空对象
codec: String, 指定编码格式，允许值为："hex", "base32", "base58", "base64", "utf8", 或者 iconv 模块支持的字符集

返回结果:

Buffer, 返回 Buffer 实例

concat

拼接多个缓存区中的数据

1
2
static Buffer Buffer.concat(Array buflist,
    Integer cutLength = -1);

调用参数:

buflist: Array, 待拼接的Buffer数组
cutLength: Integer, 截取多少个Buffer对象

返回结果:

Buffer, 拼接后产生的新 Buffer 对象

isBuffer

检测给定的变量是否是 Buffer 对象

1
static Boolean Buffer.isBuffer(Value v);

调用参数:

v: Value, 给定需要检测的变量

返回结果:

Boolean, 传入对象是否 Buffer 对象

isEncoding

检测编码格式是否被支持

1
static Boolean Buffer.isEncoding(String codec);

调用参数:

codec: String, 待检测的编码格式

返回结果:

Boolean, 是否支持

byteLength

返回字符串的实际字节长度

1
2
static Integer Buffer.byteLength(String str,
    String codec = "utf8");

调用参数:

str: String, 待取字节的字符串，如果str为 ArrayBuffer/TypedArray/DataView/Buffer 对象，则返回它们的实际长度
codec: String, 指定编码格式，允许值为："hex", "base32", "base58", "base64", "utf8", 或者 iconv 模块支持的字符集

返回结果:

Integer, 返回实际字节长度

返回字符串的实际字节长度

1
static Integer Buffer.byteLength(ArrayBuffer str);

调用参数:

str: ArrayBuffer, 待取字节的字符串，如果str为 ArrayBuffer/TypedArray/DataView/Buffer 对象，则返回它们的实际长度

返回结果:

Integer, 返回实际字节长度

返回字符串的实际字节长度

1
static Integer Buffer.byteLength(Uint8Array str);

调用参数:

str: Uint8Array, 待取字节的字符串，如果 str 为 ArrayBuffer/TypedArray/DataView/Buffer 对象，则返回它们的实际长度

返回结果:

Integer, 返回实际字节长度

返回字符串的实际字节长度

1
static Integer Buffer.byteLength(Buffer str);

调用参数:

str: Buffer, 待取字节的字符串，如果str为 ArrayBuffer/TypedArray/DataView/Buffer 对象，则返回它们的实际长度

返回结果:

Integer, 返回实际字节长度

compare

比较 buf1 和 buf2, 往往用于 Buffer 实例之间的排序. 该方式等价于 buf1.compare(buf2).

1
2
static Integer Buffer.compare(Buffer buf1,
    Buffer buf2);

调用参数:

buf1: Buffer, 待比较的 buf
buf2: Buffer, 待比较的 buf

返回结果:

Integer, 返回比较字节长度

成员属性

length

Integer, 获取缓存对象的尺寸

1readonly Integer Buffer.length;

成员函数

write

向缓存对象写入指定字符串，字符串默认为utf-8，越界时只写入部分数据

1
2
3
4
Integer Buffer.write(String str,
    Integer offset = 0,
    Integer length = -1,
    String codec = "utf8");

调用参数:

str: String, 待写入的字符串
offset: Integer, 写入起始位置
length: Integer, 写入长度（单位字节，默认值-1），未指定时为待写入字符串的长度
codec: String, 指定编码格式，允许值为："hex", "base32", "base58", "base64", "utf8", 或者 iconv 模块支持的字符集

返回结果:

Integer, 写入的数据字节长度

向缓存对象写入指定字符串，字符串默认为utf-8，越界时只写入部分数据

1
2
3
Integer Buffer.write(String str,
    Integer offset = 0,
    String codec = "utf8");

调用参数:

str: String, 待写入的字符串
offset: Integer, 写入起始位置
codec: String, 指定编码格式，允许值为："hex", "base32", "base58", "base64", "utf8", 或者 iconv 模块支持的字符集

返回结果:

Integer, 写入的数据字节长度

向缓存对象写入指定字符串，字符串默认为utf-8，越界时只写入部分数据

1
2
Integer Buffer.write(String str,
    String codec = "utf8");

调用参数:

str: String, 待写入的字符串
codec: String, 指定编码格式，允许值为："hex", "base32", "base58", "base64", "utf8", 或者 iconv 模块支持的字符集

返回结果:

Integer, 写入的数据字节长度

fill

为 Buffer 对象填充指定内容数据

1
2
3
Buffer Buffer.fill(Integer v,
    Integer offset = 0,
    Integer end = -1);

调用参数:

v: Integer, 需要填充的数据，如果未指定 offset 和 end，将填充满整个 buffer
offset: Integer, 填充起始位置
end: Integer, 填充终止位置

返回结果:

Buffer, 返回当前 Buffer 对象

为 Buffer 对象填充指定内容数据

1
2
3
Buffer Buffer.fill(Buffer v,
    Integer offset = 0,
    Integer end = -1);

调用参数:

v: Buffer, 需要填充的数据，如果未指定 offset 和 end，将填充满整个 buffer
offset: Integer, 填充起始位置
end: Integer, 填充终止位置

返回结果:

Buffer, 返回当前 Buffer 对象

为 Buffer 对象填充指定内容数据

1
2
3
4
Buffer Buffer.fill(String v,
    Integer offset = 0,
    Integer end = -1,
    String codec = "utf8");

调用参数:

v: String, 需要填充的数据，如果未指定 offset 和 end，将填充满整个 buffer
offset: Integer, 填充起始位置
end: Integer, 填充终止位置
codec: String, 指定编码格式，允许值为："hex", "base32", "base58", "base64", "utf8", 或者 iconv 模块支持的字符集

返回结果:

Buffer, 返回当前 Buffer 对象

为 Buffer 对象填充指定内容数据

1
2
3
Buffer Buffer.fill(String v,
    Integer offset,
    String codec);

调用参数:

v: String, 需要填充的数据，如果未指定 offset 和 end，将填充满整个 buffer
offset: Integer, 填充起始位置
codec: String, 指定编码格式，允许值为："hex", "base32", "base58", "base64", "utf8", 或者 iconv 模块支持的字符集

返回结果:

Buffer, 返回当前 Buffer 对象

为 Buffer 对象填充指定内容数据

1
2
Buffer Buffer.fill(String v,
    String codec);

调用参数:

v: String, 需要填充的数据，如果未指定 offset 和 end，将填充满整个 buffer
codec: String, 指定编码格式，允许值为："hex", "base32", "base58", "base64", "utf8", 或者 iconv 模块支持的字符集

返回结果:

Buffer, 返回当前 Buffer 对象

copy

从源缓存对象区域拷贝数据到目标缓存对象区域

1
2
3
4
Integer Buffer.copy(Buffer targetBuffer,
    Integer targetStart = 0,
    Integer sourceStart = 0,
    Integer sourceEnd = -1);

调用参数:

targetBuffer: Buffer, 目标缓存对象
targetStart: Integer, 目标缓存对象开始拷贝字节位置，缺省为 0
sourceStart: Integer, 源缓存对象开始字节位置, 缺省为 0
sourceEnd: Integer, 源缓存对象结束字节位置, 缺省为 -1,表示源数据长度

返回结果:

Integer, 拷贝的数据字节长度

set

从源缓存对象区域拷贝数据到目标缓存对象区域

1
2
Integer Buffer.set(Buffer src,
    Integer start);

调用参数:

src: Buffer, 目标缓存对象
start: Integer, 源缓存对象开始字节位置

返回结果:

Integer, 拷贝的数据字节长度

readUInt8

从缓存对象读取一个 8 位无符号整型数值

1
Integer Buffer.readUInt8(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Integer, 返回读取的整型数值

readUInt16LE

从缓存对象读取一个 16 位无符号整型数值，以低字节序的存储方式

1
Integer Buffer.readUInt16LE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Integer, 返回读取的整型数值

readUInt16BE

从缓存对象读取一个 16 位无符号整型数值，以高字节序的存储方式

1
Integer Buffer.readUInt16BE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Integer, 返回读取的整型数值

readUInt32LE

从缓存对象读取一个 32 位无符号整型数值，以低字节序的存储方式

1
Number Buffer.readUInt32LE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Number, 返回读取的整型数值

readUInt32BE

从缓存对象读取一个 32 位无符号整型数值，以高字节序的存储方式

1
Number Buffer.readUInt32BE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Number, 返回读取的整型数值

readUIntLE

从缓存对象读取一个无符号整型数值，最大支持 48 位，以低字节序的存储方式

1
2
Number Buffer.readUIntLE(Integer offset = 0,
    Integer byteLength = 6);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0
byteLength: Integer, 指定读取的字节数，缺省 6 个字节

返回结果:

Number, 返回读取的整型数值

readUIntBE

从缓存对象读取一个无符号整型数值，最大支持 48 位，以高字节序的存储方式

1
2
Number Buffer.readUIntBE(Integer offset = 0,
    Integer byteLength = 6);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0
byteLength: Integer, 指定读取的字节数，缺省 6 个字节

返回结果:

Number, 返回读取的整型数值

readInt64LE

从缓存对象读取一个 64 位整型数值，以低字节序的存储方式

1
Long Buffer.readInt64LE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Long, 返回读取的整型数值

readInt64BE

从缓存对象读取一个 64 位整型数值，以高字节序的存储方式

1
Long Buffer.readInt64BE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Long, 返回读取的整型数值

readInt8

从缓存对象读取一个 8 位整型数值

1
Integer Buffer.readInt8(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Integer, 返回读取的整型数值

readInt16LE

从缓存对象读取一个 16 位整型数值，以低字节序的存储方式

1
Integer Buffer.readInt16LE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Integer, 返回读取的整型数值

readInt16BE

从缓存对象读取一个 16 位整型数值，以高字节序的存储方式

1
Integer Buffer.readInt16BE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Integer, 返回读取的整型数值

readInt32LE

从缓存对象读取一个 32 位整型数值，以低字节序的存储方式

1
Integer Buffer.readInt32LE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Integer, 返回读取的整型数值

readInt32BE

从缓存对象读取一个 32 位整型数值，以高字节序的存储方式

1
Integer Buffer.readInt32BE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Integer, 返回读取的整型数值

readIntLE

从缓存对象读取一个整型数值，最大支持 48 位，以低字节序的存储方式

1
2
Number Buffer.readIntLE(Integer offset = 0,
    Integer byteLength = 6);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0
byteLength: Integer, 指定读取的字节数，缺省 6 个字节

返回结果:

Number, 返回读取的整型数值

readIntBE

从缓存对象读取一个整型数值，最大支持 48 位，以高字节序的存储方式

1
2
Number Buffer.readIntBE(Integer offset = 0,
    Integer byteLength = 6);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0
byteLength: Integer, 指定读取的字节数，缺省 6 个字节

返回结果:

Number, 返回读取的整型数值

readFloatLE

从缓存对象读取一个浮点数，以低字节序的存储方式

1
Number Buffer.readFloatLE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Number, 返回读取的浮点数

readFloatBE

从缓存对象读取一个浮点数，以高字节序的存储方式

1
Number Buffer.readFloatBE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Number, 返回读取的浮点数

readDoubleLE

从缓存对象读取一个双精度浮点数，以低字节序的存储方式

1
Number Buffer.readDoubleLE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Number, 返回读取的双精度浮点数

readDoubleBE

从缓存对象读取一个双精度浮点数，以高字节序的存储方式

1
Number Buffer.readDoubleBE(Integer offset = 0);

调用参数:

offset: Integer, 指定读取的起始位置，缺省为 0

返回结果:

Number, 返回读取的双精度浮点数

writeUInt8

向缓存对象写入一个 8 位无符号整型数值

1
2
Integer Buffer.writeUInt8(Integer value,
    Integer offset = 0);

调用参数:

value: Integer, 指定写入的数值
offset: Integer, 指定写入的起始位置

返回结果:

Integer, offset 加上写入的字节数

writeUInt16LE

向缓存对象写入一个 16 位无符号整型数值，以低字节序的存储方式

1
2
Integer Buffer.writeUInt16LE(Integer value,
    Integer offset = 0);

调用参数:

value: Integer, 指定写入的数值
offset: Integer, 指定写入的起始位置

返回结果:

Integer, offset 加上写入的字节数

writeUInt16BE

向缓存对象写入一个 16 位无符号整型数值，以高字节序的存储方式

1
2
Integer Buffer.writeUInt16BE(Integer value,
    Integer offset = 0);

调用参数:

value: Integer, 指定写入的数值
offset: Integer, 指定写入的起始位置

返回结果:

Integer, offset 加上写入的字节数

writeUInt32LE

向缓存对象写入一个 32 位无符号整型数值，以低字节序的存储方式

1
2
Integer Buffer.writeUInt32LE(Long value,
    Integer offset = 0);

调用参数:

value: Long, 指定写入的数值
offset: Integer, 指定写入的起始位置

返回结果:

Integer, offset 加上写入的字节数

writeUInt32BE

向缓存对象写入一个 32 位无符号整型数值，以高字节序的存储方式

1
2
Integer Buffer.writeUInt32BE(Long value,
    Integer offset = 0);

调用参数:

value: Long, 指定写入的数值
offset: Integer, 指定写入的起始位置

返回结果:

Integer, offset 加上写入的字节数

writeUIntLE

向缓存对象写入一个无符号整型数值，最大支持 48 位，以低字节序的存储方式

1
2
3
Integer Buffer.writeUIntLE(Long value,
    Integer offset = 0,
    Integer byteLength = 6);

调用参数:

value: Long, 指定写入的数值
offset: Integer, 指定写入的起始位置
byteLength: Integer, 指定写入的字节数，缺省 6 个字节

返回结果:

Integer, offset 加上写入的字节数

writeUIntBE

向缓存对象写入一个无符号整型数值，最大支持 48 位，以高字节序的存储方式

1
2
3
Integer Buffer.writeUIntBE(Long value,
    Integer offset = 0,
    Integer byteLength = 6);

调用参数:

value: Long, 指定写入的数值
offset: Integer, 指定写入的起始位置
byteLength: Integer, 指定写入的字节数，缺省 6 个字节

返回结果:

Integer, offset 加上写入的字节数

writeInt8

向缓存对象写入一个 8 位整型数值

1
2
Integer Buffer.writeInt8(Integer value,
    Integer offset = 0);

调用参数:

value: Integer, 指定写入的数值
offset: Integer, 指定写入的起始位置

返回结果:

Integer, offset 加上写入的字节数

writeInt16LE

向缓存对象写入一个 16 位整型数值，以低字节序的存储方式

1
2
Integer Buffer.writeInt16LE(Integer value,
    Integer offset = 0);

调用参数:

value: Integer, 指定写入的数值
offset: Integer, 指定写入的起始位置

返回结果:

Integer, offset 加上写入的字节数

writeInt16BE

向缓存对象写入一个 16 位整型数值，以高字节序的存储方式

1
2
Integer Buffer.writeInt16BE(Integer value,
    Integer offset = 0);

调用参数:

value: Integer, 指定写入的数值
offset: Integer, 指定写入的起始位置

返回结果:

Integer, offset 加上写入的字节数

writeInt32LE

Escribe un valor enteiro de 32 bits no obxecto da caché, almacenado en orde de pequeno endian

1
2
Integer Buffer.writeInt32LE(Integer value,
    Integer offset = 0);

Parámetros de chamada:

value: Número enteiro, especifica o valor que se escribirá
offset: Número enteiro, especifica a posición inicial da escritura

Resultados de devolución:

Integer, compensación máis o número de bytes escritos

writeInt32BE

Escribe un valor enteiro de 32 bits no obxecto da caché, almacenado en orde big endian

1
2
Integer Buffer.writeInt32BE(Integer value,
    Integer offset = 0);

Parámetros de chamada:

value: Número enteiro, especifica o valor que se escribirá
offset: Número enteiro, especifica a posición inicial da escritura

Resultados de devolución:

Integer, compensación máis o número de bytes escritos

writeInt64LE

Escribe un valor enteiro de 64 bits no obxecto da caché, almacenado en orde de pequeno endian

1
2
Integer Buffer.writeInt64LE(Long value,
    Integer offset = 0);

Parámetros de chamada:

value: Long, especifica o valor que se escribirá
offset: Número enteiro, especifica a posición inicial da escritura

Resultados de devolución:

Integer, compensación máis o número de bytes escritos

writeInt64BE

Escribe un valor enteiro de 64 bits no obxecto da caché, almacenado en orde big-endian

1
2
Integer Buffer.writeInt64BE(Long value,
    Integer offset = 0);

Parámetros de chamada:

value: Long, especifica o valor que se escribirá
offset: Número enteiro, especifica a posición inicial da escritura

Resultados de devolución:

Integer, compensación máis o número de bytes escritos

writeIntLE

Escribe un valor enteiro no obxecto da caché, que admite ata 48 bits e que se almacena en orde de pequeno endian.

1
2
3
Integer Buffer.writeIntLE(Long value,
    Integer offset = 0,
    Integer byteLength = 6);

Parámetros de chamada:

value: Long, especifica o valor que se escribirá
offset: Número enteiro, especifica a posición inicial da escritura
byteLength: Número enteiro, especifica o número de bytes a escribir, o valor predeterminado é 6 bytes

Resultados de devolución:

Integer, compensación máis o número de bytes escritos

writeIntBE

Escribe un valor enteiro no obxecto da caché, que admite ata 48 bits e que se almacena en orde big endian.

1
2
3
Integer Buffer.writeIntBE(Long value,
    Integer offset = 0,
    Integer byteLength = 6);

Parámetros de chamada:

value: Long, especifica o valor que se escribirá
offset: Número enteiro, especifica a posición inicial da escritura
byteLength: Número enteiro, especifica o número de bytes a escribir, o valor predeterminado é 6 bytes

Resultados de devolución:

Integer, compensación máis o número de bytes escritos

writeFloatLE

Escribe un número de coma flotante no obxecto da caché, almacenado en orde de pequeno endian

1
2
Integer Buffer.writeFloatLE(Number value,
    Integer offset);

Parámetros de chamada:

value: Número, especifica o valor que se escribirá
offset: Número enteiro, especifica a posición inicial da escritura

Resultados de devolución:

Integer, compensación máis o número de bytes escritos

writeFloatBE

Escribe un número de coma flotante no obxecto da caché, almacenado en orde big endian

1
2
Integer Buffer.writeFloatBE(Number value,
    Integer offset);

Parámetros de chamada:

value: Número, especifica o valor que se escribirá
offset: Número enteiro, especifica a posición inicial da escritura

Resultados de devolución:

Integer, compensación máis o número de bytes escritos

writeDoubleLE

Escribe un número de coma flotante de dobre precisión no obxecto da caché, almacenado en orde little-endian.

1
2
Integer Buffer.writeDoubleLE(Number value,
    Integer offset);

Parámetros de chamada:

value: Número, especifica o valor que se escribirá
offset: Número enteiro, especifica a posición inicial da escritura

Resultados de devolución:

Integer, compensación máis o número de bytes escritos

writeDoubleBE

Escribe un número de coma flotante de dobre precisión no obxecto da caché, almacenado en orde big-endian.

1
2
Integer Buffer.writeDoubleBE(Number value,
    Integer offset);

Parámetros de chamada:

value: Número, especifica o valor que se escribirá
offset: Número enteiro, especifica a posición inicial da escritura

Resultados de devolución:

Integer, compensación máis o número de bytes escritos

indexOf

Devolve a posición onde aparecen por primeira vez os datos especificados no búfer

1
2
Integer Buffer.indexOf(Integer v,
    Integer offset = 0);

Parámetros de chamada:

v: Enteiro, os datos que se van buscar. Se non se especifica a compensación, comezará por defecto desde a posición inicial.
offset: Número enteiro, posición de busca inicial

Resultados de devolución:

Integer, devolve a localización atopada, devolve -1 se non se atopa.

Devolve a posición onde aparecen por primeira vez os datos especificados no búfer

1
2
Integer Buffer.indexOf(Buffer v,
    Integer offset = 0);

Parámetros de chamada:

v: Buffer, os datos que se van buscar. Se non se especifica a compensación, comezará por defecto desde a posición inicial.
offset: Número enteiro, posición de busca inicial

Resultados de devolución:

Integer, devolve a localización atopada, devolve -1 se non se atopa.

Devolve a posición onde aparecen por primeira vez os datos especificados no búfer

1
2
Integer Buffer.indexOf(String v,
    Integer offset = 0);

Parámetros de chamada:

v: Cadea, os datos que se van buscar. Se non se especifica a compensación, comeza por defecto desde a posición inicial.
offset: Número enteiro, posición de busca inicial

Resultados de devolución:

Integer, devolve a localización atopada, devolve -1 se non se atopa.

slice

Devolve un novo obxecto de caché que contén datos desde o inicio especificado ata o final da caché

1
Buffer Buffer.slice(Integer start = 0);

Parámetros de chamada:

start: Número enteiro, especifica o inicio do intervalo, por defecto comeza desde o principio

Resultados de devolución:

Buffer, devolve o novo obxecto da caché

Devolve un novo obxecto de caché que contén o intervalo de datos especificado. Se o intervalo supera a caché, só se devolverá a parte válida dos datos.

1
2
Buffer Buffer.slice(Integer start,
    Integer end);

Parámetros de chamada:

start: Enteiro, o inicio do intervalo especificado
end: Enteiro, o final do intervalo especificado

Resultados de devolución:

Buffer, devolve o novo obxecto da caché

equals

Compara o obxecto actual co obxecto dado para a igualdade

1
Boolean Buffer.equals(object expected);

Parámetros de chamada:

expected:object, formule obxectos obxectivo para a súa comparación

Resultados de devolución:

Boolean, devolve o resultado da comparación de obxectos

compare

Comparar o contido da caché

1Integer Buffer.compare(Buffer buf);

Parámetros de chamada:

buf: Buffer, obxecto de caché que se vai comparar

Resultados de devolución:

Integer, resultados da comparación de contidos

toString

Devolve unha cadea codificada de datos binarios

1
2
3
String Buffer.toString(String codec,
    Integer offset = 0,
    Integer end);

Parámetros de chamada:

codec: Cadea, especifica o formato de codificación, os valores permitidos son: "hex", "base32", "base58", "base64", "utf8" ouiconvConxuntos de caracteres admitidos polo módulo
offset: Número enteiro, lectura da posición inicial
end: Número enteiro, lectura da posición final

Resultados de devolución:

String, devolve a representación en cadea do obxecto

Devolve unha cadea codificada de datos binarios

1
2
String Buffer.toString(String codec,
    Integer offset = 0);

Parámetros de chamada:

codec: Cadea, especifica o formato de codificación, os valores permitidos son: "hex", "base32", "base58", "base64", "utf8" ouiconvConxuntos de caracteres admitidos polo módulo
offset: Número enteiro, lectura da posición inicial

Resultados de devolución:

String, devolve a representación en cadea do obxecto

Devolve unha cadea de datos binarios codificados en UTF8

1
String Buffer.toString();

Resultados de devolución:

String, devolve a representación en cadea do obxecto

toArray

Devolve unha matriz de todos os datos binarios

1
Array Buffer.toArray();

Resultados de devolución:

Array, devolve unha matriz que contén datos do obxecto

hex

Cache o contido do obxecto mediante a codificación hexadecimal

1
String Buffer.hex();

Resultados de devolución:

String, devolve a cadea codificada

base32

usarbase32Codificación do contido do obxecto da caché

1
String Buffer.base32();

Resultados de devolución:

String, devolve a cadea codificada

base58

usarbase58Codificación do contido do obxecto da caché

1
String Buffer.base58();

Resultados de devolución:

String, devolve a cadea codificada

base64

usarbase64Codificación do contido do obxecto da caché

1
String Buffer.base64();

Resultados de devolución:

String, devolve a cadea codificada

toString

Devolve a representación en cadea do obxecto. Polo xeral, devólvese "[Obxecto nativo]". O obxecto pódese volver implementar segundo as súas propias características.

1
String Buffer.toString();

Resultados de devolución:

String, devolve a representación en cadea do obxecto

toJSON

Devolve unha representación en formato JSON do obxecto, devolvendo xeralmente unha colección de propiedades lexibles definidas polo obxecto.

1
Value Buffer.toJSON(String key = "");

Parámetros de chamada:

key: Cadena, non usada

Resultados de devolución:

Value, devolve un valor que contén JSON serializable

开发指南

基础模块

内置对象

社区模块

对象 Buffer

继承关系

构造函数

Buffer

对象

静态函数

alloc

allocUnsafe

allocUnsafeSlow

from

concat

isBuffer

isEncoding

byteLength

compare

成员属性

length

成员函数

write

fill

copy

set

readUInt8

readUInt16LE

readUInt16BE

readUInt32LE

readUInt32BE

readUIntLE

readUIntBE

readInt64LE

readInt64BE

readInt8

readInt16LE

readInt16BE

readInt32LE

readInt32BE

readIntLE

readIntBE

readFloatLE

readFloatBE

readDoubleLE

readDoubleBE

writeUInt8

writeUInt16LE

writeUInt16BE

writeUInt32LE

writeUInt32BE

writeUIntLE

writeUIntBE

writeInt8

writeInt16LE

writeInt16BE

writeInt32LE

writeInt32BE

writeInt64LE

writeInt64BE

writeIntLE

writeIntBE

writeFloatLE

writeFloatBE

writeDoubleLE

writeDoubleBE

indexOf

slice

equals

compare

toString

toArray

hex

base32

base58

base64

toString

toJSON