Node.js的缓存类Buffer-Buffer类实例属性和方法

 2015年11月22日    847     声明


创建Buffer类实例后,可以通过实例属性对缓存访问实例信息,也可以通过实例方法对缓存进行一些操作,如:切割、读写等。

  1. Buffer实例属性
  2. Buffer实例方法


1. Buffer实例属性

1.1 获取或设置指定位置字节:buffer[index]

获取或者设置在指定index索引位置的8位字节。这个值是指单个字节,其合法的范围是:16进制的0x000xFF,或0255

例如,复制一个 ASCII 字符串到一个 buffer:

var str = "itbilu.com";
var buf = new Buffer(str.length);

for (var i = 0; i < str.length ; i++) {
  buf[i] = str.charCodeAt(i);
}

console.log(buf.toString()); 
// itbilu.com


1.2 获取缓存的大小:buffer.length

获了这个buffer的bytes大小。注意,这个大小不是指缓存里面内容的大小,其大小length的依据是buffer对象所分配的内存数值,它不会随着这个buffer对象内容的改变而改变。

var buffer = new Buffer("itbilu.com");

console.log(buffer.length);	//10
buffer.write("some string", 0, "ascii");
console.log(buffer.length);	//10


2. Buffer实例方法

2.1 缓存读取方法:buffer.read*()

读取双精度数

buffer.readDoubleLE(offset[, noAssert])
buffer.readDoubleBE(offset[, noAssert])
  • offset Number
  • noAssert Boolean 可选,默认为 false
  • 返回值: Number

这两个方法会从buffer对象里,根据指定的偏移量,使用指定的endian字节序格式读取一个 64位双精度数。

设置参数 noAsserttrue表示忽略验证offset偏移量参数,这样offset可能会超出buffer的末尾。默认是 false

var buf = new Buffer(8);

buf[0] = 0x55;
buf[1] = 0x55;
buf[2] = 0x55;
buf[3] = 0x55;
buf[4] = 0x55;
buf[5] = 0x55;
buf[6] = 0xd5;
buf[7] = 0x3f;

console.log(buf.readDoubleLE(0));

// 0.3333333333333333


读取浮点数

buffer.readFloatLE(offset[, noAssert])
buffer.readFloatBE(offset[, noAssert])
  • offset Number
  • noAssert Boolean 可选,默认为 false
  • 返回值: Number

这两个方法会从buffer对象里,根据指定的偏移量,使用指定的endian字节序格式读取一个 32位双浮点数。

设置参数 noAsserttrue表示忽略验证offset偏移量参数,这样offset可能会超出buffer的末尾。默认是 false

var buf = new Buffer(4);

buf[0] = 0x00;
buf[1] = 0x00;
buf[2] = 0x80;
buf[3] = 0x3f;

console.log(buf.readFloatLE(0));   // 0x01


读取有符号整数

buffer.readIntBE(offset, byteLength[, noAssert])
buffer.readIntLE(offset, byteLength[, noAssert])
  • offset {Number} ,取值范围:0 <= offset <= buf.length
  • byteLength {Number} 取值范围:0 < byteLength <= 6
  • noAssert {Boolean} 默认为false
  • 返回值: {Number}

这是一个通用的用来作有符号整数的方法,最高支持48位精度。

var b = new Buffer(6);
b.writeUInt16LE(0x90ab, 0);
b.writeUInt32LE(0x12345678, 2);
b.readUIntLE(0, 6).toString(16);  // 6 bytes (48 bits)
// '1234567890ab'


buffer.readInt8(offset[, noAssert])
buffer.readInt16LE(offset[, noAssert])
buffer.readInt16BE(offset[, noAssert])
buffer.readInt32LE(offset[, noAssert])
buffer.readInt32BE(offset[, noAssert])
  • offset Number
  • noAssert Boolean 可选,默认为 false
  • 返回值: Number

这些都是读取有符号整型值的方法。其中readInt8会从buffer中读取有符号8位整数。其它几个方法会从buffer对象里,根据指定的偏移量,使用指定的endian字节序格式读取一个 16位或32位有符号整数。

设置参数 noAsserttrue表示忽略验证offset偏移量参数,这样offset可能会超出buffer的末尾。默认是 false


读取无符号整数
buffer.readUIntLE(offset, byteLength[, noAssert])
buffer.readUIntBE(offset, byteLength[, noAssert])
  • offset {Number} ,取值范围:0 <= offset <= buf.length
  • byteLength {Number} 取值范围:0 < byteLength <= 6
  • noAssert {Boolean} 默认为false
  • 返回值: {Number}

这是一个通用的用来作无符号整数的方法,最高支持48位精度。

var b = new Buffer(6);
b.writeUInt16LE(0x90ab, 0);
b.writeUInt32LE(0x12345678, 2);
b.readUIntLE(0, 6).toString(16);  // Specify 6 bytes (48 bits)
// output: '1234567890ab'


buffer.readUInt8(offset[, noAssert])
buffer.readIntU16LE(offset[, noAssert])
buffer.readIntU16BE(offset[, noAssert])
buffer.readIntU32LE(offset[, noAssert])
buffer.readIntU32BE(offset[, noAssert])
  • offset Number
  • noAssert Boolean 可选,默认为 false
  • 返回值: Number

这些都是读取有符号整型值的方法。其中readUInt8会从buffer中读取无符号8位整数。其它几个方法会从buffer对象里,根据指定的偏移量,使用指定的endian字节序格式读取一个 16位或32位无符号整数。

设置参数 noAsserttrue表示忽略验证offset偏移量参数,这样offset可能会超出buffer的末尾。默认是 false

var buf = new Buffer(4);

buf[0] = 0x3;
buf[1] = 0x4;
buf[2] = 0x23;
buf[3] = 0x42;

console.log(buf.readUInt32BE(0));
console.log(buf.readUInt32LE(0));

// 0x03042342
// 0x42230403


2.2 缓存写入方法:buffer.write*()

写入字符串

buffer.write(string[, offset][, length][, encoding])
  • string String 类型 - 写到buffer中字符串
  • offset Number 类型, 可选参数, 默认值: 0
  • length Number 类型, 可选参数, 默认值: buffer.length - offset
  • encoding String 类型, 可选参数, 默认值: 'utf8'
  • 返回值: Number

根据参数offset偏移量和指定的encoding编码方式,将参数string数据写入buffer。 返回值 Number 类型,表示写入了多少 8 位字节流,如果 buffer 没有足够的空间来放整个string,它将返回只写入部分字符串。

var buffer = new Buffer("abc");

var len = buffer.write("itbilu.com", 0, "ascii");
console.log(len);	//3


写入双精度数

buffer.writeDoubleLE(value, offset[, noAssert])
buffer.writeDoubleBE(value, offset[, noAssert])
  • value {Number} ,准备写入到buffer的字节数
  • offset {Number}
  • noAssert {Boolean} 默认为false
  • 返回值: {Number}

根据指定的offset偏移量和指定的endian字节序格式将64位双精度数value写入buffer

设置参数 noAsserttrue表示忽略验证valueoffset参数。 介这样可能会导致value可能过大,或者offset可能会超出offset的末尾,造成value被丢弃。这个参数除了你非常有把握,否则不应该使用它。默认是 false

var buf = new Buffer(8);
buf.writeDoubleBE(0xdeadbeefcafebabe, 0);

console.log(buf);

buf.writeDoubleLE(0xdeadbeefcafebabe, 0);

console.log(buf);

// <Buffer 43 eb d5 b7 dd f9 5f d7>
// <Buffer d7 5f f9 dd b7 d5 eb 43>


写入浮点数

buffer.writeFloatLE(value, offset[, noAssert])
buffer.writeFloatBE(value, offset[, noAssert])
  • value {Number} ,准备写入到buffer的字节数
  • offset {Number}
  • noAssert {Boolean} 默认为false
  • 返回值: {Number}

根据指定的offset偏移量和指定的endian字节序格式将32位浮点数value写入buffer

设置参数 noAsserttrue表示忽略验证valueoffset参数。 介这样可能会导致value可能过大,或者offset可能会超出offset的末尾,造成value被丢弃。这个参数除了你非常有把握,否则不应该使用它。默认是 false

var buf = new Buffer(4);
buf.writeFloatBE(0xcafebabe, 0);
console.log(buf);
// <buffer 4f 4a fe bb>

buf.writeFloatLE(0xcafebabe, 0);
console.log(buf);
// <buffer bb fe 4a 4f>


写入有符号整数

buffer.writeIntLE(value, offset, byteLength[, noAssert])
buffer.writeIntBE(value, offset, byteLength[, noAssert])
  • value {Number} ,准备写入到buffer的字节数
  • offset {Number} ,取值范围:0 <= offset <= buf.length
  • byteLength {Number} 取值范围:0 < byteLength <= 6
  • noAssert {Boolean} 默认为false
  • 返回值: {Number}

value写入到buffer,最高支持48位有符号整数。


buffer.writeIntLE(value, offset, byteLength[, noAssert])
buffer.writeIntBE(value, offset, byteLength[, noAssert])
  • value {Number} ,准备写入到buffer的字节数
  • offset {Number} ,取值范围:0 <= offset <= buf.length
  • byteLength {Number} 取值范围:0 < byteLength <= 6
  • noAssert {Boolean} 默认为false
  • 返回值: {Number}

将整型值value写入到buffer,最高支持48位无符号整数。


buffer.writeUInt8(value, offset[, noAssert])
buffer.writeInt16BE(value, offset[, noAssert])
buffer.writeInt16LE(value, offset[, noAssert])
buffer.writeInt32BE(value, offset[, noAssert])
buffer.writeInt32LE(value, offset[, noAssert])


以上方法都会根据传入的 offset 偏移量将一个合法的signed整数value 写入 buffer。其中writeUInt8()会写入一个8 位整数,其它几个方法分别会写入16位和32位endian格式的有符号整数。


设置参数 noAsserttrue表示忽略验证valueoffset参数。 介这样可能会导致value可能过大,或者offset可能会超出offset的末尾,造成value被丢弃。这个参数除了你非常有把握,否则不应该使用它。默认是 false

var buf = new Buffer(4);
buf.writeUInt32BE(0xfeedface, 0);
console.log(buf);
// <buffer fe ed fa ce>

buf.writeUInt32LE(0xfeedface, 0);
console.log(buf);
// <buffer ce fa ed fe>


写入无符号整数

buffer.writeUIntLE(value, offset, byteLength[, noAssert])
buffer.writeUIntBE(value, offset, byteLength[, noAssert])
  • value {Number} ,准备写入到buffer的字节数
  • offset {Number} ,取值范围:0 <= offset <= buf.length
  • byteLength {Number} 取值范围:0 < byteLength <= 6
  • noAssert {Boolean} 默认为false
  • 返回值: {Number}

value写入到buffer,最高支持48位无符号整数。

var b = new Buffer(6);
b.writeUIntBE(0x1234567890ab, 0, 6);
// <buffer 12 34 56 78 90 ab>


buffer.writeIntLE(value, offset, byteLength[, noAssert])
buffer.writeIntBE(value, offset, byteLength[, noAssert])
  • value {Number} ,准备写入到buffer的字节数
  • offset {Number} ,取值范围:0 <= offset <= buf.length
  • byteLength {Number} 取值范围:0 < byteLength <= 6
  • noAssert {Boolean} 默认为false
  • 返回值: {Number}

将整型值value写入到buffer,最高支持48位无符号整数。

var b = new Buffer(6);
b.writeUIntBE(0x1234567890ab, 0, 6);
// <buffer 12 34 56 78 90 ab>


buffer.writeUInt8(value, offset[, noAssert])
buffer.writeUInt16BE(value, offset[, noAssert])
buffer.writeUInt16LE(value, offset[, noAssert])
buffer.writeUInt32BE(value, offset[, noAssert])
buffer.writeUInt32LE(value, offset[, noAssert])


以上方法都会根据传入的 offset 偏移量将一个合法的signed整数value 写入 buffer。其中writeUInt8()会写入一个8 位无符号整数,其它几个方法分别会写入16位和32位endian格式的无符号整数。


设置参数 noAsserttrue表示忽略验证valueoffset参数。 介这样可能会导致value可能过大,或者offset可能会超出offset的末尾,造成value被丢弃。这个参数除了你非常有把握,否则不应该使用它。默认是 false


2.3 缓存格式转换方法

转换为字符串

buffer.toString([encoding][, start][, end])
  • encoding String 类型,可选参数,表示编码方式,默认值: 'utf8'
  • start Number 类型,可选参数,表示开始位置,默认值: 0
  • end Number 类型,可选参数,表示结束位置,默认值: buffer.length

根据指定的编码方式encoding将缓存解码为字符串。

var buffer = new Buffer(10);
buffer.write("itbilu.com", 0, "ascii");
console.log(buffer.toString());  //itbilu.com


转换为JSON对象

buffer.toJSON()

将缓存转换为JSON对象。

var buffer = new Buffer(10);
buffer.write("itbilu.com", 0, "ascii");
console.log(buffer.toJSON());
{ type: 'Buffer',
  data: [ 105, 116, 98, 105, 108, 117, 46, 99, 111, 109 ] }


2.4 Buffer实例中的其它方法

缓存对象比较

buffer.compare(otherBuffer)

返回一个数字,用于当前缓存对象是在otherBuffer之前、之后或相同。

var buf1 = new Buffer('ab');
buf1.compare(new Buffer('bc'));  //-1
buf1.compare(new Buffer('ab'));  //0
buf1.compare(new Buffer('12'));  //1


判断缓存内容是否相同

buffer.compare(otherBuffer)
  • otherBuffer {Buffer}
  • 返回值:Boolean

返回一个布尔值,用于当前缓存对象与otherBuffer是否有相同的内容。


缓存复制

buffer.copy(targetBuffer[, targetStart][, sourceStart][, sourceEnd])
  • targetBuffer Buffer,被拷贝缓存对象
  • targetStart Number,可选参数,表示目标写位置,默认值: 0
  • sourceStart Number 类型,可选参数,表示源开始复制位置,默认值: 0
  • sourceEnd Number 类型,可选参数,表示复制结束位置,默认值: buffer.length

buffer和目标buffer数据拷贝。

buf1 = new Buffer(26);
buf2 = new Buffer(26);

for (var i = 0 ; i < 26 ; i++) {
  buf1[i] = i + 97; // 97 is ASCII a
  buf2[i] = 33; // ASCII !
}

buf1.copy(buf2, 8, 16, 20);
console.log(buf2.toString('ascii', 0, 25));

// !!!!!!!!qrst!!!!!!!!!!!!!


缓存添充

buffer.fill(value[, offset][, end])
  • value,添流值
  • offset Number,可选,表示偏移量
  • end Number,可选表示结束位置

使用指定值value来填充buffer。如果没有指定 offset (默认是 0) 和end (默认是 buffer.length) ,将会填充整个buffer。

var buffer = new Buffer(50);
buffer.fill("itbilu.com ");
console.log(buffer.toString());
//itbilu.com itbilu.com itbilu.com itbilu.com itbilu


缓存数据指定位置

buffer.indexOf(value[, byteOffset])
  • value String,Buffer 或 Number
  • byteOffset Number,可选,默认值 0
  • 返回值: Number

类似Array#indexOf(),判断指定的StringBufferNumber类型的参数在buffer中的位置

var buffer = new Buffer('itbilu.com');
buffer.indexOf('lu');    //4


缓存数割

buffer.slice([start[, end]])
  • start Number,可选,默认值 0
  • end Number,可选,默认值 buf.length

返回一个新的buffer,这个bufferbufferstart(默认是 0 ) 和 end (默认是 buffer.length ) 偏移和裁剪了内存索引。当索引为负数时,则从bufferbuffer引用相同的内存地址,修改新buffer也会导致原buffer的修改。

var buf1 = new Buffer(26);

for (var i = 0 ; i < 26 ; i++) {
  buf1[i] = i + 97; // 97是ASCII中的a
}

var buf2 = buf1.slice(0, 3);
console.log(buf2.toString('ascii', 0, buf2.length));
buf1[0] = 33;
console.log(buf2.toString('ascii', 0, buf2.length));

// abc
// !bc