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

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é

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