对象 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

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

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

调用参数:

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

返回结果:

Integer, offset 加上写入的字节数

writeInt32BE

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

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

调用参数:

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

返回结果:

Integer, offset 加上写入的字节数

writeInt64LE

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

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

调用参数:

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

返回结果:

Integer, offset 加上写入的字节数

writeInt64BE

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

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

调用参数:

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

返回结果:

Integer, offset 加上写入的字节数

writeIntLE

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

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

调用参数:

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

返回结果:

Integer, offset 加上写入的字节数

writeIntBE

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

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

调用参数:

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

返回结果:

Integer, offset 加上写入的字节数

writeFloatLE

向缓存对象写入一个浮点数，以低字节序的存储方式

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

调用参数:

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

返回结果:

Integer, offset 加上写入的字节数

writeFloatBE

向缓存对象写入一个浮点数，以高字节序的存储方式

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

调用参数:

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

返回结果:

Integer, offset 加上写入的字节数

writeDoubleLE

向缓存对象写入一个双精度浮点数，以低字节序的存储方式

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

调用参数:

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

返回结果:

Integer, offset 加上写入的字节数

writeDoubleBE

向缓存对象写入一个双精度浮点数，以高字节序的存储方式

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

调用参数:

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

返回结果:

Integer, offset 加上写入的字节数

indexOf

返回某个指定数据在 Buffer 中首次出现的位置

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

调用参数:

v: Integer, 待查找数据，如果未指定 offset，默认从起始位开始
offset: Integer, 起始查找位置

返回结果:

Integer, 返回查找到的位置，未找到返回 -1

返回某个指定数据在 Buffer 中首次出现的位置

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

调用参数:

v: Buffer, 待查找数据，如果未指定 offset，默认从起始位开始
offset: Integer, 起始查找位置

返回结果:

Integer, 返回查找到的位置，未找到返回 -1

返回某个指定数据在 Buffer 中首次出现的位置

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

调用参数:

v: String, 待查找数据，如果未指定 offset，默认从起始位开始
offset: Integer, 起始查找位置

返回结果:

Integer, 返回查找到的位置，未找到返回 -1

slice

返回一个新缓存对象，包含指定起始到缓存结尾的数据

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

调用参数:

start: Integer, 指定范围的起始，缺省从头开始

返回结果:

Buffer, 返回新的缓存对象

返回一个新缓存对象，包含指定范围的数据，若范围超出缓存，则只返回有效部分数据

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

调用参数:

start: Integer, 指定范围的起始
end: Integer, 指定范围的结束

返回结果:

Buffer, 返回新的缓存对象

equals

比较当前对象与给定的对象是否相等

1
Boolean Buffer.equals(object expected);

调用参数:

expected: object, 制定比较的目标对象

返回结果:

Boolean, 객체 비교 결과를 반환합니다.

compare

比较缓存区的内容

1Integer Buffer.compare(Buffer buf);

调用参数:

buf: Buffer, 待比较缓存对象

결과 반환:

Integer, 내용 비교 결과

toString

인코딩된 바이너리 데이터 문자열을 반환합니다.

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

호출 매개변수:

codec: String, 指定编码格式，允许值为："hex", "base32", "base58", "base64", "utf8" 또는iconv모듈에서 지원하는 문자 세트
offset: 정수, 읽기 시작 위치
end: 정수, 읽기 종료 위치

결과 반환:

String, 객체의 문자열 표현을 반환합니다.

인코딩된 바이너리 데이터 문자열을 반환합니다.

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

호출 매개변수:

codec: 문자열, 인코딩 형식을 지정하며 허용되는 값은 다음과 같습니다: "hex", "base32", "base58", "base64", "utf8" 또는iconv모듈에서 지원하는 문자 세트
offset: 정수, 읽기 시작 위치

결과 반환:

String, 객체의 문자열 표현을 반환합니다.

UTF8로 인코딩된 이진 데이터 문자열을 반환합니다.

1
String Buffer.toString();

결과 반환:

String, 객체의 문자열 표현을 반환합니다.

toArray

모든 이진 데이터의 배열을 반환합니다.

1
Array Buffer.toArray();

결과 반환:

Array, 객체 데이터가 포함된 배열을 반환합니다.

hex

16진수 인코딩을 사용하여 객체 콘텐츠 캐시

1
String Buffer.hex();

결과 반환:

String, 인코딩된 문자열을 반환합니다.

base32

사용base32캐시 객체 콘텐츠 인코딩

1
String Buffer.base32();

결과 반환:

String, 인코딩된 문자열을 반환합니다.

base58

사용base58캐시 객체 콘텐츠 인코딩

1
String Buffer.base58();

결과 반환:

String, 인코딩된 문자열을 반환합니다.

base64

사용base64캐시 객체 콘텐츠 인코딩

1
String Buffer.base64();

결과 반환:

String, 인코딩된 문자열을 반환합니다.

toString

객체의 문자열 표현을 반환하며 일반적으로 "[Native Object]"를 반환하며 객체 자체의 특성에 따라 다시 구현될 수 있습니다.

1
String Buffer.toString();

결과 반환:

String, 객체의 문자열 표현을 반환합니다.

toJSON

객체의 JSON 형식 표현을 반환하며 일반적으로 객체에 의해 정의된 읽을 수 있는 속성 컬렉션을 반환합니다.

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

호출 매개변수:

key: 문자열, 사용되지 않음

결과 반환:

Value, 직렬화 가능한 JSON을 포함하는 값을 반환합니다.

开发指南

基础模块

内置对象

社区模块

对象 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