Object 内置对象

对象 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, 获取缓存对象的尺寸

1
readonly 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

比较缓存区的内容

1
Integer 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을 포함하는 값을 반환합니다.