04.缓冲区Buffer

Buffer.js 代码如下

/*----------创建Buffer实例-----------*/

//创建方法1,分配10个字节的缓存
var buf1 = new Buffer(10);

//创建方法2,指定字节数组(数组元素大小在[0,255]之间)
var buf2 = new Buffer([255,0,97,158]);

var buf2_extend = new Buffer(buf2);

//创建方法3,指定字符串(编码可为"ascii","utf8","utf16le","ucs2","base64","hex",默认为"utf-8",)
var buf3 = new Buffer('缓冲区内容','utf-8');

var buf4 = new Buffer('缓冲区内容');

/*-----------Buffer类方法------------*/

//合并缓冲区
//Buffer.concat(list[, totalLength])
var concatBuffer = Buffer.concat([new Buffer([0xaa,0xaa]),buf2]);
console.log('合并的内容:',concatBuffer);
var concatBuffer2 = Buffer.concat([new Buffer([0xaa,0xaa]),buf2],4);
console.log('限制合并总字节数的合并内容:',concatBuffer2);

/*-----------Buffer类实例属性------------*/

//返回Buffer实例的内存长度
console.log('buf4创建的缓冲区的字节长度:',buf4.length);

/*-----------Buffer类实例方法------------*/

//读取缓冲区,解码缓冲区数据并使用指定编码返回字符串
//格式如buf.toString([encoding[, start[, end]]])
//start,指定开始读取缓冲区索引的位置,默认为0
//end,结束位置(读取内容不包含end),默认为buf.length
console.log('buf4创建的缓冲区内容:',buf4.toString());

var readContent = buf4.toString('utf8',3,8);
console.log('读取buf4部分内容:',readContent,'读取的内容的字符长度为:',
			readContent.length);

//写入缓冲区并返回实际写入的字节数
//空间不足时写入部分字符串,但不写入部分字符
//格式如buf.write(string[, offset[, length]][, encoding])
//offset,开始写入缓冲区的索引值,默认为0;length,写入的字节数,默认为buf4.length-offset;
//encoding,使用的编码,默认为"utf-8"
var len = buf4.write('这里是重写的缓冲区内容,部分可见');

console.log('写入缓冲区buf4字节数:',len);
console.log('写入后buf4缓冲区内容:',buf4.toString());

//获取或设置缓冲区指定字节
console.log('buf2[2]:',buf2[2]);
buf2[2] = 98;/*0x62*/
console.log('buf2:',buf2);

//用指定的字节填充缓冲区
//格式如buf.fill(value[, offset][, end])
buf1.fill(97);
console.log('填充后的缓冲区为:',buf1.toString());

//把缓冲区字节数组转化为json的组织方式
var jsonData = buf4.toJSON();

console.log('buf4的字节数组表达方式转化为json后:',jsonData);

//比较俩换冲区,返回值为-1表示第一个缓冲区在前,0表示俩缓冲区相同,1表示第一个缓冲区在后
var compareResult = new Buffer('abcde').compare(new Buffer([97,98,99,100,101,102]));
console.log('比较后返回的数字:',compareResult);

//比较俩缓冲区是否相等,返回布尔值
var equalResult = new Buffer('abcde').equals(new Buffer([97,98,99,100,101]));
console.log('是否相等:',equalResult);

//拷贝缓冲区
//格式为buf.copy(targetBuffer[, targetStart[, sourceStart[, sourceEnd]]])
//targetStart默认为0,sourceStart默认为0,souceEnd默认为buf.length
buf4.copy(buf1);
console.log('拷贝自buf4的缓冲区内容:',buf1.toString());

//裁剪缓冲区,返回新的缓冲区,但裁剪区域与原缓冲区共用内存
//格式为buf.slice([start[, end]])
//负数索引从尾部算起
var sliceBuffer = buf4.slice(4);
console.log('剪切自buf4的缓冲区内容:',sliceBuffer.toString(),
          '字符长度为:',sliceBuffer.toString().length);
sliceBuffer.write('插',2);
console.log('修改sliceBuffer后buf4的内容:',buf4.toString());



var buf5 = new Buffer(7);
buf5.fill(98);
//写入无符号整数,大端对齐(最高48位)
//格式为buf.writeUIntBE(value, offset, byteLength[, noAssert])
//offset为buffer的偏移量,byteLength为从右算起写入的value字节数,noAssert默认为false
//noAssert为false时校验其它参数的有效性,此时byteLength必须等于value的字节长度
//且offset + byteLength <= buf.length;
//noAssert为true时,不校验参数的有效性;
buf5.writeUIntBE(0x1234567890ab,3,5,true);/*大端对齐依次写入34567890ab其中ab超出*/
console.log('大端对齐写入无符号整数',buf5);
buf5.fill(98);
//写入无符号整数,小端对齐(最高48位)
buf5.writeUIntLE(0x1234567890ab,3,5,true);/*小端对齐依次写入ab90785634其中34超出*/
console.log('小端对齐写入无符号整数',buf5);

buf5.writeUIntBE(300,3,4);
//读取无符号整数,大端对齐(最高48位)
//格式为buf.readUIntBE(offset, byteLength[, noAssert])
console.log('读取无符号整数内容(大端对齐):',buf5.readUIntBE(3,4));

buf5.writeUIntLE(300,3,4);
//读取无符号整数,小端对齐(最高48位)
console.log("读取无符号整数内容(小端对齐):",buf5.readUIntLE(3,4));


buf5.fill(98);
//写入有符号整数,大端对齐(最高48位)
buf5.writeIntBE(10,0,4);/*noAssert默认为false*/
//读取有符号整数,大端对齐(最高48位)
console.log('读取有符号整数内容(大端对齐):',buf5.readIntBE(0,4));/*noAssert为false*/
//写入有符号整数,小端对齐(最高48位)
buf5.writeIntLE(10,0,4);
//读取有符号整数,小端对齐(最高48位)
console.log("读取有符号整数内容(小端对齐):",buf5.readIntLE(0,4));


var fixBitNumber = new Buffer(65);
fixBitNumber.fill(0x62);
//写入8bit的无符号整数
//格式为buf.writeUInt8(value, offset[, noAssert])
fixBitNumber.writeUInt8(255,0);
//读取8bit的无符号整数
console.log('8bit的无符号整数:',fixBitNumber.readUInt8(0));

//写入16bit的无符号整数,大端对齐
//格式为buf.writeUInt16BE(value, offset[, noAssert])
fixBitNumber.writeUInt16BE(255,3);
//读取16bit的无符号整数
console.log('16bit的无符号整数(大端对齐):',fixBitNumber.readUInt16BE(3));

//写入16bit的无符号整数,小端对齐
//格式为buf.writeUInt16LE(value, offset[, noAssert])
fixBitNumber.writeUInt16LE(255,3);
//读取16bit的无符号整数
console.log('16bit的无符号整数(小端对齐):',fixBitNumber.readUInt16LE(3));


//写入32bit的无符号整数,大端对齐
//格式为buf.writeUInt32BE(value, offset[, noAssert])
fixBitNumber.writeUInt32BE(255,3);
//读取32bit的无符号整数
console.log('32bit的无符号整数(大端对齐):',fixBitNumber.readUInt32BE(3));
//写入32bit的无符号整数,小端对齐
//格式为buf.writeUInt32LE(value, offset[, noAssert])
fixBitNumber.writeUInt32LE(255,3);
//读取32bit的无符号整数
console.log('32bit的无符号整数(小端对齐):',fixBitNumber.readUInt32LE(3));



fixBitNumber.fill(0x62);
//写入8bit的有符号整数
//格式为buf.writeInt8(value, offset[, noAssert])
fixBitNumber.writeInt8(-128,0);
//读取8bit的有符号整数
console.log('8bit的有符号整数:',fixBitNumber.readInt8(0));

//写入16bit的有符号整数,大端对齐
//格式为buf.writeInt16BE(value, offset[, noAssert])
fixBitNumber.writeInt16BE(-255,3);
//读取16bit的有符号整数
console.log('16bit的有符号整数(大端对齐):',fixBitNumber.readInt16BE(3));

//写入16bit的有符号整数,小端对齐
//格式为buf.writeInt16LE(value, offset[, noAssert])
fixBitNumber.writeInt16LE(-255,3);
//读取16bit的有符号整数
console.log('16bit的有符号整数(小端对齐):',fixBitNumber.readInt16LE(3));


//写入32bit的有符号整数,大端对齐
//格式为buf.writeInt32BE(value, offset[, noAssert])
fixBitNumber.writeInt32BE(-255,3);
//读取32bit的有符号整数
console.log('32bit的有符号整数(大端对齐):',fixBitNumber.readInt32BE(3));
//写入32bit的有符号整数,小端对齐
//格式为buf.writeInt32LE(value, offset[, noAssert])
fixBitNumber.writeInt32LE(-255,3);
//读取32bit的有符号整数
console.log('32bit的有符号整数(小端对齐):',fixBitNumber.readInt32LE(3));

//32bit浮点数
fixBitNumber.writeFloatBE(30.25,1);
console.log('双浮点数大端对齐:',fixBitNumber.readFloatBE(1));
fixBitNumber.writeFloatLE(-30.25,2);
console.log('双浮点数小端对齐:',fixBitNumber.readFloatLE(2));

//64bit双精度
fixBitNumber.writeDoubleBE(64.125,1);
console.log('双精度数大端对齐:',fixBitNumber.readDoubleBE(1));
fixBitNumber.writeDoubleLE(-64.125,1);
console.log('双精度数小端对齐:',fixBitNumber.readDoubleLE(1));

 运行结果如下:

>node Buffer.js
合并的内容: <Buffer aa aa ff 00 61 9e>
限制合并总字节数的合并内容: <Buffer aa aa ff 00>
buf4创建的缓冲区的字节长度: 15
buf4创建的缓冲区内容: 缓冲区内容
读取buf4部分内容: 冲�� 读取的内容的字符长度为: 3
写入缓冲区buf4字节数: 15
写入后buf4缓冲区内容: 这里是重写
buf2[2]: 97
buf2: <Buffer ff 00 62 9e>
填充后的缓冲区为: aaaaaaaaaa
buf4的字节数组表达方式转化为json后: { type: 'Buffer',
  data: [ 232, 191, 153, 233, 135, 140, 230, 152, 175, 233, 135, 141, 229, 134,
153 ] }
比较后返回的数字: -1
是否相等: true
拷贝自buf4的缓冲区内容: 这里是�
剪切自buf4的缓冲区内容: ��是重写 字符长度为: 5
修改sliceBuffer后buf4的内容: 这里插重写
大端对齐写入无符号整数 <Buffer 62 62 62 34 56 78 90>
小端对齐写入无符号整数 <Buffer 62 62 62 ab 90 78 56>
读取无符号整数内容(大端对齐): 300
读取无符号整数内容(小端对齐): 300
读取有符号整数内容(大端对齐): 10
读取有符号整数内容(小端对齐): 10
8bit的无符号整数: 255
16bit的无符号整数(大端对齐): 255
16bit的无符号整数(小端对齐): 255
32bit的无符号整数(大端对齐): 255
32bit的无符号整数(小端对齐): 255
8bit的有符号整数: -128
16bit的有符号整数(大端对齐): -255
16bit的有符号整数(小端对齐): -255
32bit的有符号整数(大端对齐): -255
32bit的有符号整数(小端对齐): -255
双浮点数大端对齐: 30.25
双浮点数小端对齐: -30.25
双精度数大端对齐: 64.125
双精度数小端对齐: -64.125