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

 2015年11月22日    847     声明


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

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


1. Buffer实例属性

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

获取或者设置在指定index索引位置的8位字节。这个值是指单个字节，其合法的范围是：16进制的0x00 到0xFF，或0 到255。

例如，复制一个 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位双精度数。

设置参数 noAssert为true表示忽略验证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位双浮点数。

设置参数 noAssert为true表示忽略验证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位有符号整数。

设置参数 noAssert为true表示忽略验证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位无符号整数。

设置参数 noAssert为true表示忽略验证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。

设置参数 noAssert为true表示忽略验证value和offset参数。 介这样可能会导致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。

设置参数 noAssert为true表示忽略验证value和offset参数。 介这样可能会导致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格式的有符号整数。


设置参数 noAssert为true表示忽略验证value和offset参数。 介这样可能会导致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格式的无符号整数。


设置参数 noAssert为true表示忽略验证value和offset参数。 介这样可能会导致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()，判断指定的String、Buffer或Number类型的参数在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