对象 Buffer

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

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

var buf = new Buffer();

继承关系

构造函数

Buffer

缓存对象构造函数

new Buffer(Array datas);

调用参数:


缓存对象构造函数

new Buffer(ArrayBuffer datas);

调用参数:


缓存对象构造函数

new Buffer(TypedArray datas);

调用参数:


缓存对象构造函数

new Buffer(Buffer buffer);

调用参数:


缓存对象构造函数

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

调用参数:


缓存对象构造函数

new Buffer(Integer size = 0);

调用参数:

下标操作

缓存对象可使用下标直接访问二进制数据

Integer Buffer[];

静态函数

isBuffer

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

static Boolean Buffer.isBuffer(Value v);

调用参数:

返回结果:


concat

拼接多个缓存区中的数据

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

调用参数:

返回结果:

成员属性

length

Integer, 获取缓存对象的尺寸

readonly Integer Buffer.length;

成员函数

resize

修改缓存对象尺寸

Buffer.resize(Integer sz);

调用参数:


append

在缓存对象尾部写入一组数据

Buffer.append(Array datas);

调用参数:


在缓存对象尾部写入一组数据

Buffer.append(TypedArray datas);

调用参数:


在缓存对象尾部写入一组数据

Buffer.append(ArrayBuffer datas);

调用参数:


在缓存对象尾部写入一组二进制数据

Buffer.append(Buffer data);

调用参数:


在缓存对象尾部写入字符串,字符串将以 utf-8 格式写入

Buffer.append(String str,
    String codec = "utf8");

调用参数:


write

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

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

调用参数:

返回结果:


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

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

调用参数:

返回结果:


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

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

调用参数:

返回结果:


fill

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

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

调用参数:

返回结果:


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

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

调用参数:

返回结果:


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

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

调用参数:

返回结果:


indexOf

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

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

调用参数:

返回结果:


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

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

调用参数:

返回结果:


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

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

调用参数:

返回结果:


compare

比较缓存区的内容

Integer Buffer.compare(Buffer buf);

调用参数:

返回结果:


copy

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

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

调用参数:

返回结果:


readUInt8

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

Integer Buffer.readUInt8(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readUInt16LE

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

Integer Buffer.readUInt16LE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readUInt16BE

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

Integer Buffer.readUInt16BE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readUInt32LE

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

Long Buffer.readUInt32LE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readUInt32BE

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

Long Buffer.readUInt32BE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readUIntLE

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

Long Buffer.readUIntLE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readUIntBE

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

Long Buffer.readUIntBE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readInt8

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

Integer Buffer.readInt8(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readInt16LE

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

Integer Buffer.readInt16LE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readInt16BE

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

Integer Buffer.readInt16BE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readInt32LE

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

Integer Buffer.readInt32LE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readInt32BE

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

Integer Buffer.readInt32BE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readIntLE

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

Long Buffer.readIntLE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readIntBE

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

Long Buffer.readIntBE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readInt64LE

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

Int64 Buffer.readInt64LE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readInt64BE

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

Int64 Buffer.readInt64BE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readFloatLE

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

Number Buffer.readFloatLE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readFloatBE

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

Number Buffer.readFloatBE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readDoubleLE

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

Number Buffer.readDoubleLE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


readDoubleBE

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

Number Buffer.readDoubleBE(Integer offset = 0,
    Boolean noAssert = false);

调用参数:

返回结果:


writeUInt8

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

Buffer.writeUInt8(Integer value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeUInt16LE

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

Buffer.writeUInt16LE(Integer value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeUInt16BE

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

Buffer.writeUInt16BE(Integer value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeUInt32LE

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

Buffer.writeUInt32LE(Long value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeUInt32BE

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

Buffer.writeUInt32BE(Long value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeUIntLE

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

Buffer.writeUIntLE(Long value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeUIntBE

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

Buffer.writeUIntBE(Long value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeInt8

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

Buffer.writeInt8(Integer value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeInt16LE

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

Buffer.writeInt16LE(Integer value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeInt16BE

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

Buffer.writeInt16BE(Integer value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeInt32LE

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

Buffer.writeInt32LE(Integer value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeInt32BE

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

Buffer.writeInt32BE(Integer value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeIntLE

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

Buffer.writeIntLE(Long value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeIntBE

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

Buffer.writeIntBE(Long value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeInt64LE

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

Buffer.writeInt64LE(Int64 value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeInt64BE

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

Buffer.writeInt64BE(Int64 value,
    Integer offset = 0,
    Boolean noAssert = false);

调用参数:


writeFloatLE

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

Buffer.writeFloatLE(Number value,
    Integer offset,
    Boolean noAssert = false);

调用参数:


writeFloatBE

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

Buffer.writeFloatBE(Number value,
    Integer offset,
    Boolean noAssert = false);

调用参数:


writeDoubleLE

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

Buffer.writeDoubleLE(Number value,
    Integer offset,
    Boolean noAssert = false);

调用参数:


writeDoubleBE

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

Buffer.writeDoubleBE(Number value,
    Integer offset,
    Boolean noAssert = false);

调用参数:


slice

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

Buffer Buffer.slice(Integer start = 0);

调用参数:

返回结果:


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

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

调用参数:

返回结果:


hex

使用 16 进制编码缓存对象内容

String Buffer.hex();

返回结果:


base64

使用 base64 编码缓存对象内容

String Buffer.base64();

返回结果:


toArray

返回全部二进制数据的数组

Array Buffer.toArray();

返回结果:


toString

返回二进制数据的编码字符串

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

调用参数:

返回结果:


返回二进制数据的 utf8 编码字符串

String Buffer.toString();

返回结果:


dispose

强制回收对象,调用此方法后,对象资源将立即释放

Buffer.dispose();

equals

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

Boolean Buffer.equals(object expected);

调用参数:

返回结果:


toString

返回对象的字符串表示,一般返回 "[Native Object]",对象可以根据自己的特性重新实现

String Buffer.toString();

返回结果:


toJSON

返回对象的 JSON 格式表示,一般返回对象定义的可读属性集合

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

调用参数:

返回结果:


valueOf

返回对象本身的数值

Value Buffer.valueOf();

返回结果: