TypeScript-Int64实现

查了一些实现资料，找到以下几个Int64解决方案，整理起来。最后一个需要翻墙，直接把代码贴上，可以参考一下。

一、Javascript 的 64bit Int 支持

2个uint 拼接

这酸爽……

package lz.jprotoc
{import flash.utils.IDataInput;/*** ...* @author lizhi http://matrix3d.github.io/*/public class Int64 {public var low:uint = 0;public var high:uint = 0;public function Int64(low:uint=0,high:uint=0) {this.low = low;this.high = high;}public function equal(v:Int64):Boolean {if (v == null) return false;return (v.low == low) && (v.high == high);}public function isZero():Boolean {return low == 0 && high == 0;}public function toString():String {return "high:0x" + high.toString(16)+" low:0x" + low.toString(16);}}
}

虽然是 AS3 写的，但转成 JS 也是分分钟。

字符串拼接法

dom 同学用 ByteArray 来保存每个字节（同样是 AS3），然后将其转成字符串来显示，缺点和上面 lizi 的一样，就是无法计算。

node-int64

node-int64 采用 Javascript 的 Number 来实现对超过 int32 的数值的保存。由于 Number 采用双精度浮点数来保存数值，因此该值的范围只能在 +/- 253 的范围内。

这是我最终的选择。因为金币的值在客户端是会参与计算的，但估计在游戏的有生之年都不可能大于 253 。

我基于该版本修改了一个 TypeScript 版的 Int64.ts，可以在 egret 中使用。

Number.isSafeInteger

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger

TishoYs Space 提到了使用 Number.isSafeInteger + parseInt 来处理 Int64，需要注意几个问题：

如果服务器传递过来的是数字，因为字节序的问题（2个4字节），必须使用上面提到的方法来读取；如果服务器传递过来的是字符串，那么可以使用 parseInt。
isSafeInteger 是在 ES6 加入的，在客户端要慎用。可以使用下面的代码自行实现 Number.isSafeInteger:

Number.isSafeInteger = Number.isSafeInteger || function (value) {return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};

二、Int64.ts and Buffer.ts for Egret

前几天写了一篇 Javascript 的 64bit Int 支持，列举了一些在 Javascript 中支持 64bit 数值的已有方法。

其实，写那篇是为了在 egret 中支持 64bit 数值，原因么，上一篇有讲。

由于 egret 使用的是 TypeScript ，我基于 node-int64 翻译了一个 TypeScript 版本Int64.ts ，方便伸手党。同时为了方便和服务端大爷通信，又继承 egert.ByteArray 写了个 Buffer.ts 。

note-int64 采用的是 node 的 Buffer 来保存 64bit 数字信息。我给改成了使用 egret.ByteArray 。后来为了更加通用，又改成了直接使用 Array。

Buffer.ts 中则仅仅实现了 readInt64 和 writeInt64，Unsigned 版本直接调用这两个方法。

这两个文件都在 gist 上，请科学上网。

给一段测试代码：


var i64:Int64 = new Int64(0x1020304050607);
var buf:Buffer = new Buffer();
buf.writeInt64(i64);
buf.writeUnsignedInt64(i64.toNumber());
buf.position = 0;
for(var i:number=0;i<buf.length;i++)
{console.log(buf.readByte());
}
buf.position = 0;
console.log(buf.readInt64());
console.log(buf.readUnsignedInt64());
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 283686952306183
// 283686952306183

三、完整方案链接需要科学上网。。

https://gist.github.com/zrong/6e8d6b733158b0539bf2#file-int64-ts

Buffer.ts


// Buffer.ts
// extend egret.ByteArray, implement writeInt64
// @author zrongzrong@gmail.com
// Creation 2015-09-14
class Buffer extends egret.ByteArray
{private static SIZE_OF_INT64:number = 8;private static SIZE_OF_UINT64:number = 8;constructor(buffer?:ArrayBuffer){super(buffer);}public readUnsignedInt64(raw=true):any {return this.readInt64(raw);}public writeUnsignedInt64(value:any):void {this.writeInt64(value);}public readInt64(raw=true):any {if (!this.validate(Buffer.SIZE_OF_INT64)) return null;var buffer:Array<number> = [];for(var i:number=0; i<Buffer.SIZE_OF_INT64; i++){buffer[i] = this.readByte();}var intValue:Int64 = new Int64(buffer);if(raw){return intValue.toNumber();}return intValue;}public writeInt64(value:any):void {var intValue:Int64;if(typeof(value) == 'number'){intValue = new Int64(value);}else{intValue = value;}var buffer:Array<number> = intValue.toBuffer(true);for(var i:number=0; i<buffer.length; i++){this.writeByte(buffer[i]);}}
}

Int64.js

//     Int64.js
//
//     Copyright (c) 2012 Robert Kieffer
//     MIT License - http://opensource.org/licenses/mit-license.php/*** Support for handling 64-bit int numbers in Javascript (node.js)** JS Numbers are IEEE-754 binary double-precision floats, which limits the* range of values that can be represented with integer precision to:** 2^^53 <= N <= 2^53** Int64 objects wrap a node Buffer that holds the 8-bytes of int64 data.  These* objects operate directly on the buffer which means that if they are created* using an existing buffer then setting the value will modify the Buffer, and* vice-versa.** Internal Representation** The internal buffer format is Big Endian.  I.e. the most-significant byte is* at buffer[0], the least-significant at buffer[7].  For the purposes of* converting to/from JS native numbers, the value is assumed to be a signed* integer stored in 2's complement form.** For details about IEEE-754 see:* http://en.wikipedia.org/wiki/Double_precision_floating-point_format*///
// Int64
//
class Int64
{// Useful masks and values for bit twiddlingpublic static MASK31:number =  0x7fffffff;public static VAL31:number = 0x80000000;public static MASK32:number =  0xffffffff;public static VAL32:number = 0x100000000;public static MAX_INT:number = Math.pow(2, 53);public static MIN_INT:number = -Math.pow(2, 53);private static _HEX:Array<any> = new Array<any>();public buffer:Array<number>;public offset:number;/*** Constructor accepts any of the following argument types:** new Int64(buffer[, offset=0]) - Existing Buffer with byte offset* new Int64(Uint8Array[, offset=0]) - Existing Uint8Array with a byte offset* new Int64(string)             - Hex string (throws if n is outside int64 range)* new Int64(number)             - Number (throws if n is outside int64 range)* new Int64(hi, lo)             - Raw bits as two 32-bit values*/public constructor(a1:any, a2?:any){this._buildHex();if (a1 instanceof Array){this.buffer = a1;this.offset = a2 || 0;}else if (Object.prototype.toString.call(a1) == '[object Uint8Array]'){// Under Browserify, Buffers can extend Uint8Arrays rather than an// instance of Buffer. We could assume the passed in Uint8Array is actually// a buffer but that won't handle the case where a raw Uint8Array is passed// in. We construct a new Buffer just in case.this.buffer = Array.apply([], a1);this.offset = a2 || 0;}else{this.buffer = this.buffer || [];this.offset = 0;this.setValue.apply(this, arguments);}}// Map for converting hex octets to stringsprivate _buildHex():void{//Int64._HEX = [];for (var i = 0; i < 256; i++) {Int64._HEX[i] = (i > 0xF ? '' : '0') + i.toString(16);}}/*** Do in-place 2's compliment.  See* http://en.wikipedia.org/wiki/Two's_complement*/private _2scomp(){var b = this.buffer, o = this.offset, carry = 1;for (var i = o + 7; i >= o; i--) {var v = (b[i] ^ 0xff) + carry;b[i] = v & 0xff;carry = v >> 8;}}/*** Set the value. Takes any of the following arguments:** setValue(string) - A hexidecimal string* setValue(number) - Number (throws if n is outside int64 range)* setValue(hi, lo) - Raw bits as two 32-bit values*/public setValue(hi:any, lo?:any):void {var negate:boolean = false;if (arguments.length == 1) {if (typeof(hi) == 'number') {// Simplify bitfield retrieval by using abs() value.  We restore sign// laternegate = hi < 0;hi = Math.abs(hi);lo = hi % Int64.VAL32;hi = hi / Int64.VAL32;if (hi > Int64.VAL32) throw new RangeError(hi  + ' is outside Int64 range');hi = hi | 0;} else if (typeof(hi) == 'string') {hi = (hi + '').replace(/^0x/, '');lo = hi.substr(-8);hi = hi.length > 8 ? hi.substr(0, hi.length - 8) : '';hi = parseInt(hi, 16);lo = parseInt(lo, 16);} else {throw new Error(hi + ' must be a Number or String');}}// Technically we should throw if hi or lo is outside int32 range here, but// it's not worth the effort. Anything past the 32'nd bit is ignored.// Copy bytes to buffervar b = this.buffer, o = this.offset;for (var i = 7; i >= 0; i--) {b[o+i] = lo & 0xff;lo = i == 4 ? hi : lo >>> 8;}// Restore sign of passed argumentif (negate) this._2scomp();}/*** Convert to a native JS number.** WARNING: Do not expect this value to be accurate to integer precision for* large (positive or negative) numbers!** @param allowImprecise If true, no check is performed to verify the* returned value is accurate to integer precision.  If false, imprecise* numbers (very large positive or negative numbers) will be forced to +/-* Infinity.*/public toNumber(allowImprecise:boolean=false):number {var b = this.buffer, o = this.offset;// Running sum of octets, doing a 2's complementvar negate = b[o] & 0x80, x = 0, carry = 1;for (var i = 7, m = 1; i >= 0; i--, m *= 256) {var v = b[o+i];// 2's complement for negative numbersif (negate) {v = (v ^ 0xff) + carry;carry = v >> 8;v = v & 0xff;}x += v * m;}// Return Infinity if we've lost integer precisionif (!allowImprecise && x >= Int64.MAX_INT) {return negate ? -Infinity : Infinity;}return negate ? -x : x;}/*** Convert to a JS Number. Returns +/-Infinity for values that can't be* represented to integer precision.*/public valueOf():number {return this.toNumber(false);}/*** Return string value** @param radix Just like Number#toString()'s radix*/public toString(radix:number=10):string {return this.valueOf().toString(radix);}/*** Return a string showing the buffer octets, with MSB on the left.** @param sep separator string. default is '' (empty string)*/public toOctetString(sep:string=''):string {var out = new Array(8);var b = this.buffer, o = this.offset;for (var i = 0; i < 8; i++) {out[i] = Int64._HEX[b[o+i]];}return out.join(sep || '');}/*** Returns the int64's 8 bytes in a buffer.** @param {bool} [rawBuffer=false]  If no offset and this is true, return the internal buffer.  Should only be used if*                                  you're discarding the Int64 afterwards, as it breaks encapsulation.*/public toBuffer(rawBuffer:boolean=false):Array<number> {if (rawBuffer && this.offset === 0) return this.buffer;var out = Array.call([], this.buffer);return out;}/*** Returns a number indicating whether this comes before or after or is the* same as the other in sort order.** @param {Int64} other  Other Int64 to compare.*/public compare(other:Int64):number {// If sign bits differ ...if ((this.buffer[this.offset] & 0x80) != (other.buffer[other.offset] & 0x80)) {return other.buffer[other.offset] - this.buffer[this.offset];}// otherwise, compare bytes lexicographicallyfor (var i = 0; i < 8; i++) {if (this.buffer[this.offset+i] !== other.buffer[other.offset+i]) {return this.buffer[this.offset+i] - other.buffer[other.offset+i];}}return 0;}/*** Returns a boolean indicating if this integer is equal to other.** @param {Int64} other  Other Int64 to compare.*/public equals(other:Int64):boolean {return this.compare(other) === 0;}/*** Pretty output in console.log*/public inspect():string {return '[Int64 value:' + this + ' octets:' + this.toOctetString(' ') + ']';}
}

参考

https://blog.zengrong.net/post/2363.html
https://blog.zengrong.net/post/2367.html
https://gist.github.com/zrong/6e8d6b733158b0539bf2#file-int64-ts 感谢作者！