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

Schrijf een 32-bits geheel getalwaarde naar het cacheobject, opgeslagen in de volgorde Little Endian

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

Oproepparameters:

value: Geheel getal, specificeert de te schrijven waarde
offset: Geheel getal, specificeert de startpositie van het schrijven

Resultaten retourneren:

Integer, offset plus het aantal geschreven bytes

writeInt32BE

Schrijf een 32-bits geheel getalwaarde naar het cacheobject, opgeslagen in big endian-volgorde

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

Oproepparameters:

value: Geheel getal, specificeert de te schrijven waarde
offset: Geheel getal, specificeert de startpositie van het schrijven

Resultaten retourneren:

Integer, offset plus het aantal geschreven bytes

writeInt64LE

Schrijf een 64-bits geheel getalwaarde naar het cacheobject, opgeslagen in de volgorde Little Endian

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

Oproepparameters:

value: Lang, specificeert de waarde die moet worden geschreven
offset: Geheel getal, specificeert de startpositie van het schrijven

Resultaten retourneren:

Integer, offset plus het aantal geschreven bytes

writeInt64BE

Schrijf een 64-bits geheel getalwaarde naar het cacheobject, opgeslagen in big-endian-volgorde

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

Oproepparameters:

value: Lang, specificeert de waarde die moet worden geschreven
offset: Geheel getal, specificeert de startpositie van het schrijven

Resultaten retourneren:

Integer, offset plus het aantal geschreven bytes

writeIntLE

Schrijf een geheel getal naar het cacheobject, dat maximaal 48 bits ondersteunt en in kleine endian-volgorde wordt opgeslagen.

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

Oproepparameters:

value: Lang, specificeert de waarde die moet worden geschreven
offset: Geheel getal, specificeert de startpositie van het schrijven
byteLength: Geheel getal, specificeert het aantal te schrijven bytes, de standaardwaarde is 6 bytes

Resultaten retourneren:

Integer, offset plus het aantal geschreven bytes

writeIntBE

Schrijf een geheel getal naar het cacheobject, dat maximaal 48 bits ondersteunt en in big-endian-volgorde wordt opgeslagen.

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

Oproepparameters:

value: Lang, specificeert de waarde die moet worden geschreven
offset: Geheel getal, specificeert de startpositie van het schrijven
byteLength: Geheel getal, specificeert het aantal te schrijven bytes, de standaardwaarde is 6 bytes

Resultaten retourneren:

Integer, offset plus het aantal geschreven bytes

writeFloatLE

Schrijf een getal met drijvende komma naar het cacheobject, opgeslagen in de volgorde Little Endian

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

Oproepparameters:

value: Getal, specificeert de te schrijven waarde
offset: Geheel getal, specificeert de startpositie van het schrijven

Resultaten retourneren:

Integer, offset plus het aantal geschreven bytes

writeFloatBE

Schrijf een drijvende-kommagetal naar het cacheobject, opgeslagen in big-endian-volgorde

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

Oproepparameters:

value: Getal, specificeert de te schrijven waarde
offset: Geheel getal, specificeert de startpositie van het schrijven

Resultaten retourneren:

Integer, offset plus het aantal geschreven bytes

writeDoubleLE

Schrijft een drijvende-kommagetal met dubbele precisie naar het cacheobject, opgeslagen in de volgorde Little Endian.

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

Oproepparameters:

value: Getal, specificeert de te schrijven waarde
offset: Geheel getal, specificeert de startpositie van het schrijven

Resultaten retourneren:

Integer, offset plus het aantal geschreven bytes

writeDoubleBE

Schrijft een drijvende-kommagetal met dubbele precisie naar het cacheobject, opgeslagen in big-endian-volgorde.

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

Oproepparameters:

value: Getal, specificeert de te schrijven waarde
offset: Geheel getal, specificeert de startpositie van het schrijven

Resultaten retourneren:

Integer, offset plus het aantal geschreven bytes

indexOf

Retourneert de positie waar een opgegeven gegevens voor het eerst in de buffer verschijnt

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

Oproepparameters:

v: geheel getal, de gegevens die moeten worden doorzocht. Als de offset niet is opgegeven, wordt deze standaard gestart vanaf de startpositie.
offset: geheel getal, startzoekpositie

Resultaten retourneren:

Integer, retourneert de gevonden locatie, retourneert -1 indien niet gevonden.

Retourneert de positie waar een opgegeven gegevens voor het eerst in de buffer verschijnt

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

Oproepparameters:

v: Buffer, de gegevens waarnaar moet worden gezocht. Als de offset niet is opgegeven, begint deze standaard vanaf de startpositie.
offset: geheel getal, startzoekpositie

Resultaten retourneren:

Integer, retourneert de gevonden locatie, retourneert -1 indien niet gevonden.

Retourneert de positie waar een opgegeven gegevens voor het eerst in de buffer verschijnt

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

Oproepparameters:

v: String, de gegevens die moeten worden doorzocht. Als de offset niet is opgegeven, begint deze standaard vanaf de startpositie.
offset: geheel getal, startzoekpositie

Resultaten retourneren:

Integer, retourneert de gevonden locatie, retourneert -1 indien niet gevonden.

slice

Retourneert een nieuw cacheobject dat gegevens bevat vanaf het opgegeven begin tot het einde van de cache

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

Oproepparameters:

start: Geheel getal, specificeert het begin van het bereik, standaard vanaf het begin

Resultaten retourneren:

Buffer, retourneert het nieuwe cacheobject

Retourneert een nieuw cacheobject dat het opgegeven gegevensbereik bevat. Als het bereik de cache overschrijdt, wordt alleen het geldige deel van de gegevens geretourneerd.

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

Oproepparameters:

start: geheel getal, het begin van het opgegeven bereik
end: geheel getal, het einde van het opgegeven bereik

Resultaten retourneren:

Buffer, retourneert het nieuwe cacheobject

equals

Vergelijkt het huidige object met het gegeven object op gelijkheid

1
Boolean Buffer.equals(object expected);

Oproepparameters:

expected:object, formuleer doelobjecten ter vergelijking

Resultaten retourneren:

Boolean, retourneert het resultaat van de objectvergelijking

compare

Vergelijk cache-inhoud

1Integer Buffer.compare(Buffer buf);

Oproepparameters:

buf: Buffer, cacheobject dat moet worden vergeleken

Resultaten retourneren:

Integer, resultaten van inhoudsvergelijking

toString

Retourneert een gecodeerde reeks binaire gegevens

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

Oproepparameters:

codec: String, specificeert het coderingsformaat, toegestane waarden zijn: "hex", "base32", "base58", "base64", "utf8", oficonvTekensets ondersteund door de module
offset: Geheel getal, startpositie lezen
end: geheel getal, eindpositie lezen

Resultaten retourneren:

String, retourneert de tekenreeksrepresentatie van het object

Retourneert een gecodeerde reeks binaire gegevens

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

Oproepparameters:

codec: String, specificeert het coderingsformaat, toegestane waarden zijn: "hex", "base32", "base58", "base64", "utf8", oficonvTekensets ondersteund door de module
offset: Geheel getal, startpositie lezen

Resultaten retourneren:

String, retourneert de tekenreeksrepresentatie van het object

Retourneert een UTF8-gecodeerde reeks binaire gegevens

1
String Buffer.toString();

Resultaten retourneren:

String, retourneert de tekenreeksrepresentatie van het object

toArray

Retourneert een array met alle binaire gegevens

1
Array Buffer.toArray();

Resultaten retourneren:

Array, retourneert een array met objectgegevens

hex

Cache objectinhoud met behulp van hexadecimale codering

1
String Buffer.hex();

Resultaten retourneren:

String, retourneert de gecodeerde tekenreeks

base32

gebruikbase32Coderen van cacheobjectinhoud

1
String Buffer.base32();

Resultaten retourneren:

String, retourneert de gecodeerde tekenreeks

base58

gebruikbase58Coderen van cacheobjectinhoud

1
String Buffer.base58();

Resultaten retourneren:

String, retourneert de gecodeerde tekenreeks

base64

gebruikbase64Coderen van cacheobjectinhoud

1
String Buffer.base64();

Resultaten retourneren:

String, retourneert de gecodeerde tekenreeks

toString

Retourneert de tekenreeksweergave van het object. Over het algemeen wordt '[Native Object]' geretourneerd. Het object kan opnieuw worden geïmplementeerd op basis van zijn eigen kenmerken.

1
String Buffer.toString();

Resultaten retourneren:

String, retourneert de tekenreeksrepresentatie van het object

toJSON

Retourneert een weergave in JSON-indeling van het object, waarbij doorgaans een verzameling leesbare eigenschappen wordt geretourneerd die door het object zijn gedefinieerd.

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

Oproepparameters:

key: Tekenreeks, niet gebruikt

Resultaten retourneren:

Value, retourneert een waarde die JSON-serialiseerbaar bevat

开发指南

基础模块

内置对象

社区模块

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