├── ByteBuffer.as
├── ByteBuffer.html
├── ByteBuffer.js
├── README.md
├── package.json
└── test.js


/ByteBuffer.as:
--------------------------------------------------------------------------------
  1 | package  
  2 | {
  3 | 	import flash.utils.*;
  4 | 	
  5 | 	/**
  6 | 	 * ByteBuffer对应的as版本
  7 | 	 * sample code:
  8 | 		//压包操作
  9 | 		var sbuf:ByteBuffer = new ByteBuffer();
 10 | 		var ba:ByteArray = new ByteArray();
 11 | 		ba.writeMultiByte('123vstring','utf-8');
 12 | 		ba.position = 0;
 13 | 		var buffer:ByteArray = sbuf.string('abc123你好')//变长字符串，前两个字节表示长度
 14 | 							   .int32(-999).uint32(999).float(-0.5)
 15 | 							   .int64(9999999).double(-0.000005).short(32767).ushort(65535)
 16 | 							   .byte(255)
 17 | 							   .vstring('abcd',5)//定长字符串,不足的字节补0x00
 18 | 							   .byteArray(ba,10)//字节数组，不足字节补0x00
 19 | 							   .pack();//结尾调用打包方法
 20 | 
 21 | 		trace(buffer);
 22 | 		
 23 | 		//解包操作
 24 | 		var rbuf:ByteBuffer = new ByteBuffer(buffer);
 25 | 		//解包出来是一个数组
 26 | 		var arr:Array = rbuf.string()//变长字符串，前两个字节表示长度
 27 | 							.int32().uint32().float()
 28 | 							.int64().double().short().ushort()
 29 | 							.byte()
 30 | 							.vstring(null,5)//定长字符串,不足的字节补0x00
 31 | 							.byteArray(null,10)//字节数组，不足字节补0x00
 32 | 							.unpack();//结尾调用解包方法
 33 | 
 34 | 		trace(arr);
 35 | 	 * @author yoyo 2014 https://github.com/play175/ByteBuffer
 36 | 	 */
 37 | 	public class ByteBuffer 
 38 | 	{
 39 | 		public static const Type_Byte:int = 1;
 40 | 		public static const Type_Short:int = 2;
 41 | 		public static const Type_UShort:int = 3;
 42 | 		public static const Type_Int32:int = 4;
 43 | 		public static const Type_UInt32:int = 5;
 44 | 		public static const Type_String:int = 6;//变长字符串，前两个字节表示长度
 45 | 		public static const Type_VString:int = 7;//定长字符串
 46 | 		public static const Type_Int64:int = 8;
 47 | 		public static const Type_Float:int = 9;
 48 | 		public static const Type_Double:int = 10;
 49 | 		public static const Type_ByteArray:int = 11;
 50 | 
 51 | 		
 52 | 		private var _org_buf:ByteArray;
 53 | 		private var _encoding:String = 'utf-8';
 54 | 		private var _offset:int;
 55 | 		private var _list:Array = [];
 56 | 		private var _endian:String = 'B';
 57 | 
 58 | 		public function ByteBuffer(org_buf:ByteArray = null,offset:int = 0) 
 59 | 		{
 60 | 			_org_buf = org_buf;
 61 | 			_offset = offset || 0;
 62 | 			setEndian();
 63 | 		}
 64 | 		
 65 | 		/**指定文字编码**/
 66 | 		public function encoding (encode:String):ByteBuffer{
 67 | 			_encoding = encode;
 68 | 			return this;
 69 | 		}
 70 | 		
 71 | 		private function setEndian(ba:ByteArray = null):void
 72 | 		{
 73 | 			if (ba == null) ba = _org_buf;
 74 | 		   if (ba)ba.endian = _endian == 'B'?Endian.BIG_ENDIAN:Endian.LITTLE_ENDIAN;
 75 | 		}
 76 |     
 77 | 		/**指定字节序 为BigEndian**/
 78 | 		public function bigEndian ():ByteBuffer{
 79 | 		   _endian = 'B';
 80 | 		   setEndian();
 81 | 			return this;
 82 | 		}
 83 | 
 84 | 		/**指定字节序 为LittleEndian**/
 85 | 		public function littleEndian ():ByteBuffer{
 86 | 		   _endian = 'L';
 87 | 		   setEndian();
 88 | 			return this;
 89 | 		}
 90 | 
 91 | 		public function byte (val:int = undefined,index:int = undefined):ByteBuffer{
 92 | 			if (arguments.length == 0) {
 93 | 				_org_buf.position = _offset;
 94 | 			   _list.push(_org_buf.readByte());
 95 | 			   _offset+=1;
 96 | 			}else{
 97 | 				_list.splice((arguments.length >= 2) ? index : _list.length,0,{t:Type_Byte,d:val,l:1});
 98 | 				_offset += 1;
 99 | 			}
100 | 			return this;
101 | 		}
102 | 
103 | 		public function short (val:int = undefined,index:int = undefined):ByteBuffer{
104 | 			if(arguments.length == 0){
105 | 				_org_buf.position = _offset;
106 | 			   _list.push(_org_buf.readShort());
107 | 			   _offset+=2;
108 | 			}else{
109 | 				_list.splice((arguments.length >= 2) ? index : _list.length,0,{t:Type_Short,d:val,l:2});
110 | 				_offset += 2;
111 | 			}
112 | 			return this;
113 | 		}
114 | 
115 | 		public function ushort (val:int = undefined,index:int = undefined):ByteBuffer{
116 | 			if(arguments.length == 0){
117 | 				_org_buf.position = _offset;
118 | 			   _list.push(_org_buf.readUnsignedShort());
119 | 			   _offset+=2;
120 | 			}else{
121 | 				_list.splice((arguments.length >= 2) ? index : _list.length,0,{t:Type_UShort,d:val,l:2});
122 | 				_offset += 2;
123 | 			}
124 | 			return this;
125 | 		}
126 | 
127 | 		public function int32 (val:int = undefined,index:int = undefined):ByteBuffer{
128 | 			if(arguments.length == 0){
129 | 				_org_buf.position = _offset;
130 | 			   _list.push(_org_buf.readInt());
131 | 			   _offset+=4;
132 | 			}else{
133 | 				_list.splice((arguments.length >= 2) ? index : _list.length,0,{t:Type_Int32,d:val,l:4});
134 | 				_offset += 4;
135 | 			}
136 | 			return this;
137 | 		}
138 | 
139 | 		public function uint32 (val:int = undefined,index:int = undefined):ByteBuffer{
140 | 			if(arguments.length == 0){
141 | 				_org_buf.position = _offset;
142 | 			   _list.push(_org_buf.readUnsignedInt());
143 | 			   _offset+=4;
144 | 			}else{
145 | 				_list.splice((arguments.length >= 2) ? index : _list.length,0,{t:Type_UInt32,d:val,l:4});
146 | 				_offset += 4;
147 | 			}
148 | 			return this;
149 | 		}
150 | 
151 | 		/**
152 | 		* 变长字符串 前2个字节表示字符串长度
153 | 		**/
154 | 		public function string (val:String = undefined,index:int = undefined):ByteBuffer{
155 | 			var len:int = 0;
156 | 			if(!val){
157 | 				_org_buf.position = _offset;
158 | 			   len = _org_buf.readUnsignedShort();
159 | 			   _offset+=2;
160 | 				_org_buf.position = _offset;
161 | 			   _list.push(_org_buf.readMultiByte(len,_encoding));
162 | 			   _offset+=len;
163 | 			}else{
164 | 				len = stringByteLen(val);
165 | 				_list.splice((arguments.length >= 2) ? index : _list.length,0,{t:Type_String,d:val,l:len});
166 | 				_offset += len + 2;
167 | 			}
168 | 			return this;
169 | 		}
170 | 
171 | 		/**
172 | 		* 定长字符串 val为null时，读取定长字符串（需指定长度len）
173 | 		**/
174 | 		public function vstring (val:String = undefined,len:int = undefined,index:int = undefined):ByteBuffer{
175 | 			if(!val){
176 | 				_org_buf.position = _offset;
177 | 			   _list.push(_org_buf.readMultiByte(len,_encoding));
178 | 				_offset+=len;
179 | 			}else{
180 | 				_list.splice((arguments.length >= 3) ? index : _list.length,0,{t:Type_VString,d:val,l:len});
181 | 				_offset += len;
182 | 			}
183 | 			return this;
184 | 		}
185 | 
186 | 		public function int64 (val:Number = undefined,index:int = undefined):ByteBuffer{
187 | 			if(arguments.length == 0){
188 | 				_org_buf.position = _offset;
189 | 			   _list.push(_org_buf.readDouble());
190 | 			   _offset+=8;
191 | 			}else{
192 | 				_list.splice((arguments.length >= 2) ? index : _list.length,0,{t:Type_Int64,d:val,l:8});
193 | 				_offset += 8;
194 | 			}
195 | 			return this;
196 | 		}
197 | 
198 | 		public function float (val:Number = undefined,index:int = undefined):ByteBuffer{
199 | 			if(arguments.length == 0){
200 | 				_org_buf.position = _offset;
201 | 			   _list.push(_org_buf.readFloat());
202 | 			   _offset+=4;
203 | 			}else{
204 | 				_list.splice((arguments.length >= 2) ? index : _list.length,0,{t:Type_Float,d:val,l:4});
205 | 				_offset += 4;
206 | 			}
207 | 			return this;
208 | 		}
209 | 
210 | 		public function double (val:Number = undefined,index:int = undefined):ByteBuffer{
211 | 			if(arguments.length == 0){
212 | 				_org_buf.position = _offset;
213 | 			   _list.push(_org_buf.readDouble());
214 | 			   _offset+=8;
215 | 			}else{
216 | 				_list.splice((arguments.length >= 2) ? index : _list.length,0,{t:Type_Double,d:val,l:8});
217 | 				_offset += 8;
218 | 			}
219 | 			return this;
220 | 		}
221 | 		
222 | 		/**
223 | 		* 写入或读取一段字节数组
224 | 		**/
225 | 		public function byteArray (val:ByteArray = undefined,len:int = undefined,index:int = undefined):ByteBuffer{
226 | 			 var arr:ByteArray;
227 | 			if(!val){
228 | 				_org_buf.position = _offset;
229 | 				arr = new ByteArray();
230 | 				setEndian(arr);
231 | 				arr.position = 0;
232 | 				_org_buf.readBytes(arr, 0, len);
233 | 				_list.push(arr);
234 | 			   _offset+=len;
235 | 			}else {
236 | 				//拷贝字节数组
237 | 				arr = new ByteArray();
238 | 				setEndian(arr);
239 | 				arr.position = 0;
240 | 				arr.writeBytes(val, val.position, val.bytesAvailable);
241 | 				arr.position = 0;
242 | 				_list.splice((arguments.length >= 3) ? index : _list.length,0,{t:Type_ByteArray,d:arr,l:len});
243 | 				_offset += len;
244 | 			}
245 | 			return this;
246 | 		}
247 | 
248 | 		/**
249 | 		* 解包成数据数组
250 | 		**/
251 | 		public function unpack ():Array{
252 | 			return _list;
253 | 		}
254 | 		
255 | 		/**
256 | 		* 打包成二进制,在前面加上2个字节表示包长
257 | 		**/
258 | 		public function packWithHead ():ByteArray {
259 | 			return pack(true);
260 | 		}
261 | 
262 | 		/**
263 | 		* 打包成二进制
264 | 		* @param ifHead 是否在前面加上2个字节表示包长
265 | 		**/
266 | 		public function pack (ifHead:Boolean = false):ByteArray{
267 | 			_org_buf = new ByteArray();
268 | 			setEndian();
269 | 			_org_buf.position = 0;
270 | 			if(ifHead){
271 | 				_org_buf.writeShort(_offset);
272 | 			}
273 | 			var i:int, j:int,end:int;
274 | 			for (i = 0; i < _list.length; i++) {
275 | 				switch(_list[i].t){
276 | 					case Type_Byte:
277 | 						_org_buf.writeByte(_list[i].d);
278 | 						break;
279 | 					case Type_Short:
280 | 						_org_buf.writeShort(_list[i].d);
281 | 						break;
282 | 					case Type_UShort:
283 | 						_org_buf.writeShort(_list[i].d);
284 | 						break;
285 | 					case Type_Int32:
286 | 						_org_buf.writeInt(_list[i].d);
287 | 						break;
288 | 					case Type_UInt32:
289 | 						_org_buf.writeUnsignedInt(_list[i].d);
290 | 						break;
291 | 					case Type_String:
292 | 						//前2个字节表示字符串长度
293 | 						_org_buf.writeShort(_list[i].l);
294 | 						_org_buf.writeMultiByte(_list[i].d, _encoding);
295 | 						break;
296 | 					case Type_VString:
297 | 						var vlen:int = stringByteLen(_list[i].d);//字符串实际长度
298 | 						_org_buf.writeMultiByte(_list[i].d, _encoding);
299 | 						//补齐\0
300 | 						for(j = _org_buf.position,end = _org_buf.position + (_list[i].l - vlen);j<end;j++) {
301 | 							 _org_buf.writeByte(0);
302 | 						}
303 | 						break;
304 | 					case Type_Int64:
305 | 						_org_buf.writeDouble(_list[i].d);
306 | 						break;
307 | 					case Type_Float:
308 | 						_org_buf.writeFloat(_list[i].d);
309 | 						break;
310 | 					case Type_Double:
311 | 						_org_buf.writeDouble(_list[i].d);
312 | 						break;
313 | 					case Type_ByteArray:
314 | 						_org_buf.writeBytes(_list[i].d, 0, _list[i].d.length);
315 | 						for(j = _org_buf.position,end = _org_buf.position + (_list[i].l - _list[i].d.length);j<end;j++){
316 | 							 _org_buf.writeByte(0);
317 | 						}
318 | 						break;
319 | 				}
320 | 			}
321 | 			_org_buf.position = 0;
322 | 			return _org_buf;
323 | 		}
324 |     
325 | 		 /**
326 | 		* 未读数据长度
327 | 		**/
328 | 		public function getAvailable ():int{
329 | 			if(!_org_buf)return _offset;
330 | 			return _org_buf.length - _offset;
331 | 		}
332 | 		
333 | 		public function stringByteLen(txtStr:String):int {
334 | 			if(txtStr == null) return 0;
335 | 			var bytes:ByteArray = new ByteArray();
336 | 			bytes.writeMultiByte(txtStr,_encoding);
337 | 			return bytes.length;
338 | 		}
339 | 	}
340 | 
341 | }


--------------------------------------------------------------------------------
/ByteBuffer.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html lang="en">
  3 | 
  4 | <head>
  5 |     <meta charset="UTF-8">
  6 |     <title>ByteBuffer for browser</title>
  7 | </head>
  8 | 
  9 | <body>
 10 |     <script type="text/javascript">
 11 |         /*
 12 |         * 构造方法
 13 |         * @param org_buf 需要解包的二进制
 14 |         * @param offset 指定数据在二进制的初始位置 默认是0
 15 |         */
 16 |         var ByteBuffer = function (arrayBuf, offset) {
 17 | 
 18 |             var Type_Byte = 1;
 19 |             var Type_Short = 2;
 20 |             var Type_UShort = 3;
 21 |             var Type_Int32 = 4;
 22 |             var Type_UInt32 = 5;
 23 |             var Type_String = 6;//变长字符串，前两个字节表示长度
 24 |             var Type_VString = 7;//定长字符串
 25 |             var Type_Int64 = 8;
 26 |             var Type_Float = 9;
 27 |             var Type_Double = 10;
 28 |             var Type_ByteArray = 11;
 29 | 
 30 |             var _org_buf = arrayBuf ? (arrayBuf.constructor == DataView ? arrayBuf : (arrayBuf.constructor == Uint8Array ? new DataView(arrayBuf.buffer, offset) : new DataView(arrayBuf, offset))) : new DataView(new Uint8Array([]).buffer);
 31 |             var _offset = offset || 0;
 32 |             var _list = [];
 33 | 			var _littleEndian = false;
 34 |     
 35 | 			//指定字节序 为BigEndian
 36 | 			this.bigEndian = function(){
 37 | 			   _littleEndian = false;
 38 | 				return this;
 39 | 			};
 40 | 
 41 | 			//指定字节序 为LittleEndian
 42 | 			this.littleEndian = function(){
 43 | 			   _littleEndian = true;
 44 | 				return this;
 45 | 			};
 46 | 
 47 |             if (!ArrayBuffer.prototype.slice) {
 48 |                 ArrayBuffer.prototype.slice = function (start, end) {
 49 |                     var that = new Uint8Array(this);
 50 |                     if (end == undefined) end = that.length;
 51 |                     var result = new ArrayBuffer(end - start);
 52 |                     var resultArray = new Uint8Array(result);
 53 |                     for (var i = 0; i < resultArray.length; i++)
 54 |                         resultArray[i] = that[i + start];
 55 |                     return result;
 56 |                 }
 57 |             }
 58 | 
 59 |             function utf8Write(view, offset, str) {
 60 | 			  var c = 0;
 61 | 			  for (var i = 0, l = str.length; i < l; i++) {
 62 | 				c = str.charCodeAt(i);
 63 | 				if (c < 0x80) {
 64 | 				  view.setUint8(offset++, c);
 65 | 				}
 66 | 				else if (c < 0x800) {
 67 | 				  view.setUint8(offset++, 0xc0 | (c >> 6));
 68 | 				  view.setUint8(offset++, 0x80 | (c & 0x3f));
 69 | 				}
 70 | 				else if (c < 0xd800 || c >= 0xe000) {
 71 | 				  view.setUint8(offset++, 0xe0 | (c >> 12));
 72 | 				  view.setUint8(offset++, 0x80 | (c >> 6) & 0x3f);
 73 | 				  view.setUint8(offset++, 0x80 | (c & 0x3f));
 74 | 				}
 75 | 				else {
 76 | 				  i++;
 77 | 				  c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
 78 | 				  view.setUint8(offset++, 0xf0 | (c >> 18));
 79 | 				  view.setUint8(offset++, 0x80 | (c >> 12) & 0x3f);
 80 | 				  view.setUint8(offset++, 0x80 | (c >> 6) & 0x3f);
 81 | 				  view.setUint8(offset++, 0x80 | (c & 0x3f));
 82 | 				}
 83 | 			  }
 84 | 			}
 85 | 
 86 | 			function utf8Read(view, offset, length) {
 87 | 			  var string = '', chr = 0;
 88 | 			  for (var i = offset, end = offset + length; i < end; i++) {
 89 | 				var byte = view.getUint8(i);
 90 | 				if ((byte & 0x80) === 0x00) {
 91 | 				  string += String.fromCharCode(byte);
 92 | 				  continue;
 93 | 				}
 94 | 				if ((byte & 0xe0) === 0xc0) {
 95 | 				  string += String.fromCharCode(
 96 | 					((byte & 0x0f) << 6) |
 97 | 					(view.getUint8(++i) & 0x3f)
 98 | 				  );
 99 | 				  continue;
100 | 				}
101 | 				if ((byte & 0xf0) === 0xe0) {
102 | 				  string += String.fromCharCode(
103 | 					((byte & 0x0f) << 12) |
104 | 					((view.getUint8(++i) & 0x3f) << 6) |
105 | 					((view.getUint8(++i) & 0x3f) << 0)
106 | 				  );
107 | 				  continue;
108 | 				}
109 | 				if ((byte & 0xf8) === 0xf0) {
110 | 				  chr = ((byte & 0x07) << 18) |
111 | 					((view.getUint8(++i) & 0x3f) << 12) |
112 | 					((view.getUint8(++i) & 0x3f) << 6) |
113 | 					((view.getUint8(++i) & 0x3f) << 0);
114 | 				  if (chr >= 0x010000) { // surrogate pair
115 | 					chr -= 0x010000;
116 | 					string += String.fromCharCode((chr >>> 10) + 0xD800, (chr & 0x3FF) + 0xDC00);
117 | 				  } else {
118 | 					string += String.fromCharCode(chr);
119 | 				  }
120 | 				  continue;
121 | 				}
122 | 				throw new Error('Invalid byte ' + byte.toString(16));
123 | 			  }
124 | 			  return string;
125 | 			}
126 | 
127 | 			function utf8Length(str) {
128 | 			  var c = 0, length = 0;
129 | 			  for (var i = 0, l = str.length; i < l; i++) {
130 | 				c = str.charCodeAt(i);
131 | 				if (c < 0x80) {
132 | 				  length += 1;
133 | 				}
134 | 				else if (c < 0x800) {
135 | 				  length += 2;
136 | 				}
137 | 				else if (c < 0xd800 || c >= 0xe000) {
138 | 				  length += 3;
139 | 				}
140 | 				else {
141 | 				  i++;
142 | 				  length += 4;
143 | 				}
144 | 			  }
145 | 			  return length;
146 | 			}
147 | 
148 |             this.byte = function (val, index) {
149 |                 if (arguments.length == 0) {
150 |                     _list.push(_org_buf.getUint8(_offset,_littleEndian));
151 |                     _offset += 1;
152 |                 } else {
153 |                     _list.splice(index != undefined ? index : _list.length, 0, { t: Type_Byte, d: val, l: 1 });
154 |                     _offset += 1;
155 |                 }
156 |                 return this;
157 |             };
158 | 
159 |             this.short = function (val, index) {
160 |                 if (arguments.length == 0) {
161 |                     _list.push(_org_buf.getInt16(_offset,_littleEndian));
162 |                     _offset += 2;
163 |                 } else {
164 |                     _list.splice(index != undefined ? index : _list.length, 0, { t: Type_Short, d: val, l: 2 });
165 |                     _offset += 2;
166 |                 }
167 |                 return this;
168 |             };
169 | 
170 |             this.ushort = function (val, index) {
171 |                 if (arguments.length == 0) {
172 |                     _list.push(_org_buf.getUint16(_offset,_littleEndian));
173 |                     _offset += 2;
174 |                 } else {
175 |                     _list.splice(index != undefined ? index : _list.length, 0, { t: Type_UShort, d: val, l: 2 });
176 |                     _offset += 2;
177 |                 }
178 |                 return this;
179 |             };
180 | 
181 |             this.int32 = function (val, index) {
182 |                 if (arguments.length == 0) {
183 |                     _list.push(_org_buf.getInt32(_offset,_littleEndian));
184 |                     _offset += 4;
185 |                 } else {
186 |                     _list.splice(index != undefined ? index : _list.length, 0, { t: Type_Int32, d: val, l: 4 });
187 |                     _offset += 4;
188 |                 }
189 |                 return this;
190 |             };
191 | 
192 |             this.uint32 = function (val, index) {
193 |                 if (arguments.length == 0) {
194 |                     _list.push(_org_buf.getUint32(_offset,_littleEndian));
195 |                     _offset += 4;
196 |                 } else {
197 |                     _list.splice(index != undefined ? index : _list.length, 0, { t: Type_UInt32, d: val, l: 4 });
198 |                     _offset += 4;
199 |                 }
200 |                 return this;
201 |             };
202 | 
203 |             /**
204 |             * 变长字符串 前4个字节表示字符串长度
205 |             **/
206 |             this.string = function (val, index) {
207 |                 if (arguments.length == 0) {
208 |                     var len = _org_buf.getInt32(_offset,_littleEndian);
209 |                     _offset += 4;
210 |                     _list.push(utf8Read(_org_buf,_offset,len));
211 |                     _offset += len;
212 |                 } else {
213 |                     var len = 0;
214 |                     if (val) {
215 |                         len = utf8Length(val);
216 |                     }
217 |                     _list.splice(index != undefined ? index : _list.length, 0, { t: Type_String, d: val, l: len });
218 |                     _offset += len + 4;
219 |                 }
220 |                 return this;
221 |             };
222 | 
223 |             /**
224 |             * 定长字符串 val为null时，读取定长字符串（需指定长度len）
225 |             **/
226 |             this.vstring = function (val, len, index) {
227 |                 if (!len) {
228 |                     throw new Error('vstring must got len argument');
229 |                     return this;
230 |                 }
231 |                 if (val == undefined || val == null) {
232 |                     var vlen = 0;//实际长度
233 |                     for (var i = _offset; i < _offset + len; i++) {
234 |                         if (_org_buf.getUint8(i) > 0) vlen++;
235 |                     }
236 |                     _list.push(utf8Read(_org_buf,_offset,vlen));
237 |                     _offset += len;
238 |                 } else {
239 |                     _list.splice(index != undefined ? index : _list.length, 0, { t: Type_VString, d: val, l: len });
240 |                     _offset += len;
241 |                 }
242 |                 return this;
243 |             };
244 | 
245 |             this.int64 = function (val, index) {
246 |                 if (arguments.length == 0) {
247 |                     _list.push(_org_buf.getFloat64(_offset,_littleEndian));
248 |                     _offset += 8;
249 |                 } else {
250 |                     _list.splice(index != undefined ? index : _list.length, 0, { t: Type_Int64, d: val, l: 8 });
251 |                     _offset += 8;
252 |                 }
253 |                 return this;
254 |             };
255 | 
256 |             this.float = function (val, index) {
257 |                 if (arguments.length == 0) {
258 |                     _list.push(_org_buf.getFloat32(_offset,_littleEndian));
259 |                     _offset += 4;
260 |                 } else {
261 |                     _list.splice(index != undefined ? index : _list.length, 0, { t: Type_Float, d: val, l: 4 });
262 |                     _offset += 4;
263 |                 }
264 |                 return this;
265 |             };
266 | 
267 |             this.double = function (val, index) {
268 |                 if (arguments.length == 0) {
269 |                     _list.push(_org_buf.getFloat64(_offset,_littleEndian));
270 |                     _offset += 8;
271 |                 } else {
272 |                     _list.splice(index != undefined ? index : _list.length, 0, { t: Type_Double, d: val, l: 8 });
273 |                     _offset += 8;
274 |                 }
275 |                 return this;
276 |             };
277 | 
278 |             /**
279 |             * 写入或读取一段字节数组
280 |             **/
281 |             this.byteArray = function (val, len, index) {
282 |                 if (!len) {
283 |                     throw new Error('byteArray must got len argument');
284 |                     return this;
285 |                 }
286 |                 if (val == undefined || val == null) {
287 |                     var arr = new Uint8Array(_org_buf.buffer.slice(_offset, _offset + len));
288 |                     _list.push(arr);
289 |                     _offset += len;
290 |                 } else {
291 |                     _list.splice(index != undefined ? index : _list.length, 0, { t: Type_ByteArray, d: val, l: len });
292 |                     _offset += len;
293 |                 }
294 |                 return this;
295 |             };
296 | 
297 |             /**
298 |             * 解包成数据数组
299 |             **/
300 |             this.unpack = function () {
301 |                 return _list;
302 |             };
303 | 
304 |             /**
305 |             * 打包成二进制,在前面加上4个字节表示包长
306 |             **/
307 |             this.packWithHead = function () {
308 |                 return this.pack(true);
309 |             };
310 | 
311 |             /**
312 |             * 打包成二进制
313 |             * @param ifHead 是否在前面加上4个字节表示包长
314 |             **/
315 |             this.pack = function (ifHead) {
316 |                 _org_buf = new DataView(new ArrayBuffer((ifHead) ? _offset + 4 : _offset));
317 |                 var offset = 0;
318 |                 if (ifHead) {
319 |                     _org_buf.setUint32(offset, _offset,_littleEndian);
320 |                     offset += 4;
321 |                 }
322 |                 for (var i = 0; i < _list.length; i++) {
323 |                     switch (_list[i].t) {
324 |                         case Type_Byte:
325 |                             _org_buf.setInt8(offset, _list[i].d);
326 |                             offset += _list[i].l;
327 |                             break;
328 |                         case Type_Short:
329 |                             _org_buf.setInt16(offset, _list[i].d,_littleEndian);
330 |                             offset += _list[i].l;
331 |                             break;
332 |                         case Type_UShort:
333 |                             _org_buf.setUint16(offset, _list[i].d,_littleEndian);
334 |                             offset += _list[i].l;
335 |                             break;
336 |                         case Type_Int32:
337 |                             _org_buf.setInt32(offset, _list[i].d,_littleEndian);
338 |                             offset += _list[i].l;
339 |                             break;
340 |                         case Type_UInt32:
341 |                             _org_buf.setUint32(offset, _list[i].d,_littleEndian);
342 |                             offset += _list[i].l;
343 |                             break;
344 |                         case Type_String:
345 |                             //前4个字节表示字符串长度
346 |                             _org_buf.setUint32(offset, _list[i].l,_littleEndian);
347 |                             offset += 4;
348 | 							utf8Write(_org_buf,offset,_list[i].d);
349 |                             offset += _list[i].l;
350 |                             break;
351 |                         case Type_VString:
352 | 							utf8Write(_org_buf,offset,_list[i].d);
353 |                             var vlen = utf8Length(_list[i].d);//字符串实际长度
354 |                             //补齐\0
355 |                             for (var j = offset + vlen; j < offset + _list[i].l; j++) {
356 |                                 _org_buf.setUint8(j, 0);
357 |                             }
358 |                             offset += _list[i].l;
359 |                             break;
360 |                         case Type_Int64:
361 |                             _org_buf.setFloat64(offset, _list[i].d,_littleEndian);
362 |                             offset += _list[i].l;
363 |                             break;
364 |                         case Type_Float:
365 |                             _org_buf.setFloat32(offset, _list[i].d,_littleEndian);
366 |                             offset += _list[i].l;
367 |                             break;
368 |                         case Type_Double:
369 |                             _org_buf.setFloat64(offset, _list[i].d,_littleEndian);
370 |                             offset += _list[i].l;
371 |                             break;
372 |                         case Type_ByteArray:
373 |                             var indx = 0;
374 |                             for (var j = offset; j < offset + _list[i].l; j++) {
375 |                                 if (indx < _list[i].d.length) {
376 |                                     _org_buf.setUint8(j, _list[i].d[indx]);
377 |                                 } else {//不够的话，后面补齐0x00
378 |                                     _org_buf.setUint8(j, 0);
379 |                                 }
380 |                                 indx++
381 |                             }
382 |                             offset += _list[i].l;
383 |                             break;
384 |                     }
385 |                 }
386 |                 return _org_buf.buffer;
387 |             };
388 | 
389 |             /**
390 |            * 未读数据长度
391 |            **/
392 |             this.getAvailable = function () {
393 |                 if (!_org_buf) return _offset;
394 |                 return _org_buf.buffer.byteLength - _offset;
395 |             };
396 |         }
397 | 
398 |         //压包操作
399 |         var sbuf = new ByteBuffer().littleEndian();
400 |         var buffer = sbuf.string('abc123你好')//变长字符串，utf8编码，前4个字节表示字符串长度
401 |             .int32(-999).uint32(999).float(-0.5)
402 |             .int64(9999999).double(-0.000005).short(32767).ushort(65535)
403 |             .byte(255)
404 |             .vstring('abcd', 10)//定长字符串，utf8编码,不足的字节补0x00
405 |             .byteArray(new Uint8Array([65, 66, 67, 68, 69]), 5)//字节数组，不足字节补0x00
406 |             .pack();//结尾调用打包方法
407 | 
408 |         //buffer 类型是ArrayBuffer
409 |         console.log(buffer);
410 | 
411 |         //解包操作
412 |         var rbuf = new ByteBuffer(buffer).littleEndian();
413 |         //解包出来是一个数组
414 |         var arr = rbuf.string()//变长字符串，utf8编码，前4个字节表示字符串长度
415 |             .int32().uint32().float()
416 |             .int64().double().short().ushort()
417 |             .byte()
418 |             .vstring(null, 10)//定长字符串，utf8编码,不足的字节补0x00
419 |             .byteArray(null, 5)//字节数组，不足字节补0x00
420 |             .unpack();//结尾调用解包方法
421 | 
422 |         console.log(arr);
423 | 
424 | 
425 |     </script>
426 | </body>
427 | 
428 | </html>


--------------------------------------------------------------------------------
/ByteBuffer.js:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * ByteBuffer
  3 |  * yoyo 2012 https://github.com/play175/ByteBuffer
  4 |  * new BSD Licensed
  5 |  */
  6 | 
  7 | var Type_Byte = 1;
  8 | var Type_Short = 2;
  9 | var Type_UShort = 3;
 10 | var Type_Int32 = 4;
 11 | var Type_UInt32 = 5;
 12 | var Type_String = 6;//变长字符串，前两个字节表示长度
 13 | var Type_VString = 7;//定长字符串
 14 | var Type_Int64 = 8;
 15 | var Type_Float = 9;
 16 | var Type_Double = 10;
 17 | var Type_ByteArray = 11;
 18 | 
 19 | /*
 20 | * 构造方法
 21 | * @param org_buf 需要解包的二进制
 22 | * @param offset 指定数据在二进制的初始位置 默认是0
 23 | */
 24 | var ByteBuffer = function (org_buf,offset) {
 25 | 
 26 |     var _org_buf = org_buf;
 27 |     var _encoding = 'utf8';
 28 |     var _offset = offset || 0;
 29 |     var _list = [];
 30 |     var _endian = 'B';
 31 | 
 32 |     //指定文字编码
 33 |     this.encoding = function(encode){
 34 |         _encoding = encode;
 35 |         return this;
 36 |     };
 37 |     
 38 |     //指定字节序 为BigEndian
 39 |     this.bigEndian = function(){
 40 |        _endian = 'B';
 41 |         return this;
 42 |     };
 43 | 
 44 |     //指定字节序 为LittleEndian
 45 |     this.littleEndian = function(){
 46 |        _endian = 'L';
 47 |         return this;
 48 |     };
 49 | 
 50 |     this.byte = function(val,index){
 51 |         if(val == undefined || val == null){
 52 |            _list.push(_org_buf.readUInt8(_offset));
 53 |            _offset+=1;
 54 |         }else{
 55 |             _list.splice(index != undefined ? index : _list.length,0,{t:Type_Byte,d:val,l:1});
 56 |             _offset += 1;
 57 |         }
 58 |         return this;
 59 |     };
 60 | 
 61 |     this.short = function(val,index){
 62 |         if(val == undefined || val == null){
 63 |            _list.push(_org_buf['readInt16'+_endian+'E'](_offset));
 64 |            _offset+=2;
 65 |         }else{
 66 |             _list.splice(index != undefined ? index : _list.length,0,{t:Type_Short,d:val,l:2});
 67 |             _offset += 2;
 68 |         }
 69 |         return this;
 70 |     };
 71 | 
 72 |     this.ushort = function(val,index){
 73 |         if(val == undefined || val == null){
 74 |            _list.push(_org_buf['readUInt16'+_endian+'E'](_offset));
 75 |            _offset+=2;
 76 |         }else{
 77 |             _list.splice(index != undefined ? index : _list.length,0,{t:Type_UShort,d:val,l:2});
 78 |             _offset += 2;
 79 |         }
 80 |         return this;
 81 |     };
 82 | 
 83 |     this.int32 = function(val,index){
 84 |         if(val == undefined || val == null){
 85 |            _list.push(_org_buf['readInt32'+_endian+'E'](_offset));
 86 |            _offset+=4;
 87 |         }else{
 88 |             _list.splice(index != undefined ? index : _list.length,0,{t:Type_Int32,d:val,l:4});
 89 |             _offset += 4;
 90 |         }
 91 |         return this;
 92 |     };
 93 | 
 94 |     this.uint32 = function(val,index){
 95 |         if(val == undefined || val == null){
 96 |            _list.push(_org_buf['readUInt32'+_endian+'E'](_offset));
 97 |            _offset+=4;
 98 |         }else{
 99 |             _list.splice(index != undefined ? index : _list.length,0,{t:Type_UInt32,d:val,l:4});
100 |             _offset += 4;
101 |         }
102 |         return this;
103 |     };
104 | 
105 |     /**
106 |     * 变长字符串 前2个字节表示字符串长度
107 |     **/
108 |     this.string = function(val,index){
109 |         if(val == undefined || val == null){
110 |            var len = _org_buf['readInt16'+_endian+'E'](_offset);
111 |            _offset+=2;
112 |            _list.push(_org_buf.toString(_encoding, _offset, _offset+len));
113 |            _offset+=len;
114 |         }else{
115 |             var len = 0;
116 |             if(val)len = Buffer.byteLength(val, _encoding);
117 |             _list.splice(index != undefined ? index : _list.length,0,{t:Type_String,d:val,l:len});
118 |             _offset += len + 2;
119 |         }
120 |         return this;
121 |     };
122 | 
123 |     /**
124 |     * 定长字符串 val为null时，读取定长字符串（需指定长度len）
125 |     **/
126 |     this.vstring = function(val,len,index){
127 |         if(!len){
128 |             throw new Error('vstring must got len argument');
129 |             return this;
130 |         }
131 |         if(val == undefined || val == null){
132 |             var vlen = 0;//实际长度
133 |             for(var i = _offset;i<_offset +len;i++){
134 |                 if(_org_buf[i]>0)vlen++;
135 |             }
136 |             _list.push(_org_buf.toString(_encoding, _offset, _offset+vlen));
137 |             _offset+=len;
138 |         }else{
139 |             _list.splice(index != undefined ? index : _list.length,0,{t:Type_VString,d:val,l:len});
140 |             _offset += len;
141 |         }
142 |         return this;
143 |     };
144 | 
145 |     this.int64 = function(val,index){
146 |         if(val == undefined || val == null){
147 |            _list.push(_org_buf['readDouble'+_endian+'E'](_offset));
148 |            _offset+=8;
149 |         }else{
150 |             _list.splice(index != undefined ? index : _list.length,0,{t:Type_Int64,d:val,l:8});
151 |             _offset += 8;
152 |         }
153 |         return this;
154 |     };
155 | 
156 |     this.float = function(val,index){
157 |         if(val == undefined || val == null){
158 |            _list.push(_org_buf['readFloat'+_endian+'E'](_offset));
159 |            _offset+=4;
160 |         }else{
161 |             _list.splice(index != undefined ? index : _list.length,0,{t:Type_Float,d:val,l:4});
162 |             _offset += 4;
163 |         }
164 |         return this;
165 |     };
166 | 
167 |     this.double = function(val,index){
168 |         if(val == undefined || val == null){
169 |            _list.push(_org_buf['readDouble'+_endian+'E'](_offset));
170 |            _offset+=8;
171 |         }else{
172 |             _list.splice(index != undefined ? index : _list.length,0,{t:Type_Double,d:val,l:8});
173 |             _offset += 8;
174 |         }
175 |         return this;
176 |     };
177 | 
178 |     /**
179 |     * 写入或读取一段字节数组
180 |     **/
181 |     this.byteArray = function(val,len,index){
182 |         if(!len){
183 |             throw new Error('byteArray must got len argument');
184 |             return this;
185 |         }
186 |         if(val == undefined || val == null){
187 |             var arr = [];
188 |             for(var i = _offset;i<_offset +len;i++){
189 |                 if(i<_org_buf.length){
190 |                     arr.push(_org_buf.readUInt8(i));
191 |                 }else{
192 |                     arr.push(0);
193 |                 }
194 |             }
195 |             _list.push(arr);
196 |            _offset+=len;
197 |         }else{
198 |             _list.splice(index != undefined ? index : _list.length,0,{t:Type_ByteArray,d:val,l:len});
199 |             _offset += len;
200 |         }
201 |         return this;
202 |     };
203 | 
204 |     /**
205 |     * 解包成数据数组
206 |     **/
207 |     this.unpack = function(){
208 |         return _list;
209 |     };
210 |     
211 |     /**
212 |     * 打包成二进制,在前面加上2个字节表示包长
213 |     **/
214 |     this.packWithHead = function(){
215 |       return this.pack(true);
216 |     };
217 | 
218 |     /**
219 |     * 打包成二进制
220 |     * @param ifHead 是否在前面加上2个字节表示包长
221 |     **/
222 |     this.pack = function(ifHead){
223 |         _org_buf = new Buffer((ifHead)?_offset+2:_offset);
224 |         var offset = 0;
225 |         if(ifHead){
226 |             _org_buf['writeUInt16'+_endian+'E'](_offset,offset);
227 |             offset+=2;
228 |         }
229 |         for (var i = 0; i < _list.length; i++) {
230 |             switch(_list[i].t){
231 |                 case Type_Byte:
232 |                     _org_buf.writeUInt8(_list[i].d,offset);
233 |                     offset+=_list[i].l;
234 |                     break;
235 |                 case Type_Short:
236 |                     _org_buf['writeInt16'+_endian+'E'](_list[i].d,offset);
237 |                     offset+=_list[i].l;
238 |                     break;
239 |                 case Type_UShort:
240 |                     _org_buf['writeUInt16'+_endian+'E'](_list[i].d,offset);
241 |                     offset+=_list[i].l;
242 |                     break;
243 |                 case Type_Int32:
244 |                     _org_buf['writeInt32'+_endian+'E'](_list[i].d,offset);
245 |                     offset+=_list[i].l;
246 |                     break;
247 |                 case Type_UInt32:
248 |                     _org_buf['writeUInt32'+_endian+'E'](_list[i].d,offset);
249 |                     offset+=_list[i].l;
250 |                     break;
251 |                 case Type_String:
252 |                     //前2个字节表示字符串长度
253 |                     _org_buf['writeInt16'+_endian+'E'](_list[i].l,offset);
254 |                     offset+=2;
255 |                     _org_buf.write(_list[i].d, offset, _encoding);
256 |                     offset+=_list[i].l;
257 |                     break;
258 |                 case Type_VString:
259 |                     var vlen = Buffer.byteLength(_list[i].d, _encoding);//字符串实际长度
260 |                     _org_buf.write(_list[i].d, offset, _encoding);
261 |                     //补齐\0
262 |                     for(var j = offset + vlen;j<offset+_list[i].l;j++){
263 |                          _org_buf.writeUInt8(0,j);
264 |                     }
265 |                     offset+=_list[i].l;
266 |                     break;
267 |                 case Type_Int64:
268 |                     _org_buf['writeDouble'+_endian+'E'](_list[i].d,offset);
269 |                     offset+=_list[i].l;
270 |                     break;
271 |                 case Type_Float:
272 |                     _org_buf['writeFloat'+_endian+'E'](_list[i].d,offset);
273 |                     offset+=_list[i].l;
274 |                     break;
275 |                 case Type_Double:
276 |                     _org_buf['writeDouble'+_endian+'E'](_list[i].d,offset);
277 |                     offset+=_list[i].l;
278 |                     break;
279 |                 case Type_ByteArray:
280 |                     var indx = 0;
281 |                     for(var j = offset;j<offset+_list[i].l;j++){
282 |                          if(indx<_list[i].d.length){
283 |                             _org_buf.writeUInt8(_list[i].d[indx],j);
284 |                          }else{//不够的话，后面补齐0x00
285 |                             _org_buf.writeUInt8(0,j);
286 |                          }
287 |                          indx++
288 |                     }
289 |                     offset+=_list[i].l;
290 |                     break;
291 |             }
292 |         }
293 |         return _org_buf;
294 |     };
295 |     
296 |      /**
297 |     * 未读数据长度
298 |     **/
299 |     this.getAvailable = function(){
300 |         if(!_org_buf)return _offset;
301 |         return _org_buf.length - _offset;
302 |     };
303 | }
304 | 
305 | module.exports = exports = ByteBuffer;


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | nodejs版本的ByteBuffer和C++通信的利器！
 2 | 
 3 | 推荐结合ExBuffer来实现网络协议：https://github.com/play175/ExBuffer
 4 | 
 5 | ```javascript
 6 | var ByteBuffer = require('./ByteBuffer');
 7 | 
 8 | /*************************基本操作****************************/
 9 | 
10 | //压包操作
11 | var sbuf = new ByteBuffer();
12 | var buffer = sbuf.string('abc123你好')//变长字符串，前两个字节表示长度
13 |                        .int32(-999).uint32(999).float(-0.5)
14 |                        .int64(9999999).double(-0.000005).short(32767).ushort(65535)
15 |                        .byte(255)
16 |                        .vstring('abcd',5)//定长字符串,不足的字节补0x00
17 |                        .byteArray([65,66,67,68,69],5)//字节数组，不足字节补0x00
18 |                        .pack();//结尾调用打包方法
19 | 
20 | console.log(buffer);
21 | 
22 | //解包操作
23 | var rbuf = new ByteBuffer(buffer);
24 | //解包出来是一个数组
25 | var arr = rbuf.string()//变长字符串，前两个字节表示长度
26 |                     .int32().uint32().float()
27 |                     .int64().double().short().ushort()
28 |                     .byte()
29 |                     .vstring(null,5)//定长字符串,不足的字节补0x00
30 |                     .byteArray(null,5)//字节数组，不足字节补0x00
31 |                     .unpack();//结尾调用解包方法
32 | 
33 | console.log(arr);
34 | 
35 | 
36 | /*************************更多操作****************************/
37 | 
38 | //指定字符编码(默认：utf8):utf8/ascii/
39 | var sbuf = new ByteBuffer().encoding('ascii');
40 | 
41 | //指定字节序(默认：BigEndian)
42 | var sbuf = new ByteBuffer().littleEndian();
43 | 
44 | //指定数据在二进制的初始位置 默认是0
45 | var sbuf = new ByteBuffer(buffer,2);
46 | 
47 | //插入数据到指定位置
48 | var sbuf = new ByteBuffer();
49 | sbuf.int32(9999,0);//把这个int32数据插入到ByteBuffer的第一个位置
50 | 
51 | //在打包的时候在开始位置插入一个short型表示包长(通信层中的包头)
52 | var buffer = sbuf.packWithHead();
53 | 
54 | ```
55 | 
56 | install
57 | ```javascript
58 | npm install ByteBuffer -g
59 | ```
60 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ByteBuffer",
 3 |   "description": "pack or unpack a byte array",
 4 |   "homepage"      : "http://play175.github.com/ByteBuffer/",
 5 |   "keywords": [
 6 |     "Buffer",
 7 |     "byte array",
 8 |     "pack",
 9 |     "unpack"
10 |   ],
11 |   "author"        : "yoyo <http://yoyo.play175.com>",
12 |   "repository"    : {"type": "git", "url": "https://github.com/play175/ByteBuffer.git"},
13 |   "main": "ByteBuffer.js",
14 |   "version"       : "0.3.0"
15 | }


--------------------------------------------------------------------------------
/test.js:
--------------------------------------------------------------------------------
 1 | var ByteBuffer = require('./ByteBuffer');
 2 | 
 3 | /*************************基本操作****************************/
 4 | 
 5 | //压包操作
 6 | var sbuf = new ByteBuffer();
 7 | var buffer = sbuf.string('abc123你好')//变长字符串，前两个字节表示长度
 8 |                        .int32(-999).uint32(999).float(-0.5)
 9 |                        .int64(9999999).double(-0.000005).short(32767).ushort(65535)
10 |                        .byte(255)
11 |                        .vstring('abcd',5)//定长字符串,不足的字节补0x00
12 |                        .byteArray([65,66,67,68,69],5)//字节数组，不足字节补0x00
13 |                        .pack();//结尾调用打包方法
14 | 
15 | console.log(buffer);
16 | 
17 | //解包操作
18 | var rbuf = new ByteBuffer(buffer);
19 | //解包出来是一个数组
20 | var arr = rbuf.string()//变长字符串，前两个字节表示长度
21 |                     .int32().uint32().float()
22 |                     .int64().double().short().ushort()
23 |                     .byte()
24 |                     .vstring(null,5)//定长字符串,不足的字节补0x00
25 |                     .byteArray(null,5)//字节数组，不足字节补0x00
26 |                     .unpack();//结尾调用解包方法
27 | 
28 | console.log(arr);
29 | 
30 | 
31 | /*************************更多操作****************************/
32 | 
33 | //指定字符编码(默认：utf8):utf8/ascii/
34 | var sbuf = new ByteBuffer().encoding('ascii');
35 | 
36 | //指定字节序(默认：BigEndian)
37 | var sbuf = new ByteBuffer().littleEndian();
38 | 
39 | //指定数据在二进制的初始位置 默认是0
40 | var sbuf = new ByteBuffer(buffer,2);
41 | 
42 | //插入数据到指定位置
43 | var sbuf = new ByteBuffer();
44 | sbuf.int32(9999,0);//把这个int32数据插入到ByteBuffer的第一个位置
45 | 
46 | //在打包的时候在开始位置插入一个short型表示包长(通信层中的包头)
47 | var buffer = sbuf.packWithHead();
48 | 


--------------------------------------------------------------------------------