Nodejs - Buffer

由于其中的一些函数用法都是一样的，只翻译了其中几个

Buffer

       Stablity:3–稳定的

纯粹的javascript支持unicode码而对二进制不是很支持，当解决TCP流或者文件流的时候，处理流是有必要的。Node有很多的策略来解决流的问题

 

原始的资料存储在buffer类中，缓冲区和一个数字数组类似但和在V8引擎中的原始数据分派也是一致的，一个缓冲区不能调整大小

 

Buufer类是全局的，使用它不需要用require来获取

 

转换缓冲区到字符串对象需要一个明确的编码分发。下面是不同的编码方法

Ascii, urf8, usc2, utf16le, base64, binary,hex

 

Buffer对象也可以使用各类行的数组，buffer对象克隆到ArrayBuffer，经常用来存储各类行的数组。Buffer的内存和ArrayBuffer不是共享的

 

NOTE： node.jsv0,8 在array.buffer简单的定义缓冲区而不是克隆他

 

当需要更高的效率时，他引入了类型化数组规范，ArrayBuffer#slice()赋值了一份在buffer#slice创建了一个视图的时候

 

Class: Buffer

Buffer类是一个全局类型用来解决二进制数据，它可以在多种情况下构建

 

New Buffer(size);

.size Numbr

分配一个新的size大小的缓冲区

 

New Buffer(array)

. array Array

用array初始化分派一个新的缓冲区

New Buffer(str, [encoding])

.str String – 字符串编码

.encoding String- 任意的编码方式

分配一个新的缓冲区给str，编码方式默认为utf8

 

Class 方法:

Buffer.isEncoding(encoding)

字符串编码，测试有没有这种编码方式

如果encoding是一种有效的编码的方式返回true，否则返回false

 

Buf.write(string, [offset], [length],[encoding])

.string – 写入缓冲区的数据

.offset Number, 任意数字，默认 0

.length Number, 任意的，默认 buffer.length – offset

Encoding String,默认utf-8

用所给的编码方式在缓冲区的编码位置写入字符串，offset默认为0，编码默认为utf8，legth是写入的数据的字节数，返回写入的字符的字节数，如果缓冲区没有足够的空间来储存字符串，他将会写入字符串的一部分，length默认为buffer.length – offset,这个方法不会写局部的字符

Buf = new Buffer(256);

Len = buf.write(‘\u00bd + \u00bc = \u00be’,0 );

Console.log(len + “bytes:” + buf.toString(‘utf8’,0, len));

写入的字符被设定在Buffer._charsWritten并且将会在下一次调用buf.write()重写

Buf.toString([encoding], [start], [end])

.encoding String,默认为utf8

.start Number : 默认0

.End Number: 默认为buffer.length

解码并返回一个缓冲区数据编码方式为encoding，从start到end字节

Buf.toJSON

返回一个json-buffer的实例，和输出的Json数组是完全一样的，json.stringify暗中调用这个函数当生成一个buffer实例时

 

Example:

Var buf = new Buffer(‘test’);

Var json = JSON.stringify(buf);

 

Console.log(json);

//’[116, 101, 115, 116]’

 

Var copy = new Buffer(JSON.parse(json));

 

Console.log(copy);

//<Buffer 74, 65, 73, 784);>

 

Buf[index]

获取并设置在index字节的位置，这个值指的是单个的字节，所以这个合法的范围是从00 到 0xff,或是 0 – 255；

Example: 复制一个ascii’字符串进缓冲区，每一次一个字节

 

Str = “node.js”

Buf = new Buffer(str.length);

For(var I = 0; i < str.length; i ++) {

       Buf[i]= str.charCodeAt[i];

}

 

Console.log(buf);

//node.js

Class Method: Buffer.isBuffer(obj)

.obj Object

.Return: Booelan

测试这个obj是不是Buffer类得

 

Class Method: Buffer.byteLength(string,[encoding]);

.string String

.encoding String, 随意的， 默认为 utf8
return: Number

给字符串一个字符长度的字节，，编码默认为utf8，这和String.prototype.length是不一样的，因为返回字符串的长度

Example:

Str = ‘\u00d + \u00dc = \u00be’;

Console.log(str + “: ” + str.length + “characters,” +

       Buffer.byteLength(str,‘utf8’) + “bytes”);

// 1/2 + 1/4 = 3/4: 9 characters, 12bytes

 

Class Method: Buffer.concat(list,[totalLength])

.list Array 合并列表的Buffer对象

.totalLength Number 当合并的时候所有的buffer的宽度

 

返回一个合并了所有的buffer对象列表的缓冲区

如果这个列表没东西，或者这个totalLength是0，那么返回一个0宽度的缓冲区

如果这个列表只有一个对象，那么列表的第一个对象返回

如果这个列表有更多的对象，那么创建一个新的缓冲区

 

如果没有提供totalLength，他从列表里读出缓冲对象，然而，这给该函数添加了一个额外的循环，这比明确的添加一个宽度要快

 

Buf .length

这个缓冲区的字节大小，标记这个内容的大小是没有必要地，length指定了缓冲区对象分配的内存的大小。当这个内容的缓冲区改变的时候，他并不会改变。

Buf = newBuffer(1234);

Console.log(buf.length)l

Buf.write(“somestring”, 0, “ascii”);

Console.log(buf,length);

 

//1234

//1234

 

Buf.copy(targetBuffer,[targetStart], [sourceStart], [sourceEnd])

targetBuffer BufferObject – 复制进入

targetStartNumber, Optional, 默认 0

source StartNumber, 默认0

sourceEndNumber, 默认buffer.length

 

在缓冲区之间复制，资源和目标可以重叠，targetState和sourceStart默认为0，sourceEnd默认为buffer.length

 

所有传递给的不合发值将会设置成默认值

 

Example: 建立两个buffer，然后复制一个到另一个，从第八个字节开始

Buf1 = newBuffer(26);

Buf2 = newBuffer(26);

 

For(var I = 0; I< 26; i ++) {

   Buf1[i] = I + 97;

Buf2[i] = 33;                                                                            

}

Buf1.copy(buf2,8, 16, 20);

Console.log(buf2.toString(‘ascii’,0, 25));

 

//!!!!!!!!QRST!!!!!!!!!!!

 

Buf.slice([start],[end])

.start Number, 默认0

.end Numberm 默认为buffer.legth

 返回新的缓冲区引用的是以前的内存但是被start和end切割,负数从缓冲区的最后开始

修改新的缓冲区的快将会修改原来的缓冲区

Example: 创建一个acsii字母表的缓冲区，获取一个slice，然后修改一个字符

Var buf1 = newBuffer(26);

 

For(var I = 0; I< 26; I ++) {

 Buf1[i] = I + 97; //97 is ASCII a

}

Var buf2 =buf1.slice(0,3);

Console.log(buf2.toString(‘ascii’,0, buf2.length));

Buf[0] = 33;

Console.log(buf2.toString(‘ascii’,0, buf2.length));

 

//adc

//!bc

 

Buf.readUInt8(offset,[noAssert])

.offset Number

.noAssertBoolearn, Optional, 默认false

.Return: Number

从缓冲区读取一个无标识的8位的数字

设置noAssert 为true跳过offset验证，这意味着offset可以超出buffer的末尾，默认为false

 

Example:

Var buf = newBuffer(4);

Buf[0] = 0x3;

Buf[1] = 0x4;

Buf[2] = 0x23;

Buf[3] = 0x42;

 

For(ii = 0; ii< buf.length; ii ++) {

Console.log(buf.readUInt8(ii));

}

 

Buf.readUInt16LE(offset,[noAssert])

Buf.readUInt16BE(offset,[noAssert])

.offset Number

.noAssertBoolean, Opitional, Default: false

.Return: Number

读取一个十六位的数字从缓冲区在特定的移位之后

设置noAssert为true可以跳过offset验证，这意味着offset可以超过末尾，默认为false

Var buf = newBuffer(4);

 

Buf[0] = 0x3;

Buf[1] = 0x4;

Buf[2] = 0x23;

Buf[3] = 0x42;

 

Console.log(buf.readUInit16BE(0));

Console.log(buf.readUInt16LE(0));

Console.log(buf.readUInt16BE(1));

Console.log(buf.readUInt16LE(1));

Console.log(buf.readUInt16BE(2));

Console.log(buf.readUInt16LE(2));

 

//0x0304

//0xo403

//0x0423

//0x2304

//0x2342

//0x4223

 

Buf.fill(value,[offset], [end])

.value

.offset Number,Optional

.end Number,Optiaonal

用特定的值填充buffer，如果offset和end没有指定，那么将会填充整个缓冲区

 

Var b = newBuffer(50);

b.fill(“h”);

 

buffer.INSPECT_MAX_BYTES

.number 默认50

当buffer.inspect()被调用的时候将会返回多少的字节？这可以被用户模块重写。

记住这是一个被缓冲区模块require(‘buffer’)返回的属性，并不是buffer的全局变量，或者buffer的实例

 

Class ：SlowBuffer

这个类是为内部用户设计的，javascript程序应该使用buffer而不是slowBuffer;

 

为了避免给小的内存块分配过多的C++对象在服务器的使用中，记住分配8Kb内存块，，如果一个buffer比这个值小，那么他将会通过父类slowBuffer对象返回，如果他比这个大，那么node将会分配一个slowBuffer片给他