int64-native

int64-native is a simple uint64_t wrapper for JavaScript, enabling the
use of 64-bit unsigned integers from node.

Why?

int64-native was originally developed to support reasonable handling of
64-bit ID columns in databases. There are other 64-bit integer modules out
there, but AFAICT all of them are pure JavaScript; native uint64_t seemed
like a better way to handle this!

The one caveat is that you won't be able to use this browser-side. However,
you can use the string representation to pass 64-bit values from server to
client.

Installing

$3

npm install int64-native

$3

git clone git://github.com/candu/node-int64-native.git
cd node-int64-native
npm install

int64-native is built using node-gyp.

Usage

All of the following examples are borrowed from test/int64.js, which you
can run via

npm test

$3

require() gives you direct access to the constructor:

var Int64 = require('int64-native');

$3

You can create an Int64 as follows:

var x = new Int64(),
y = new Int64(42),
z = new Int64(0xfedcba98, 0x76543210),
w = new Int64('0xfedcba9876543210')
expect(x.toString()).to.equal('0x0000000000000000');
expect(y.toString()).to.equal('0x000000000000002a');
expect(z.toString()).to.equal('0xfedcba9876543210');
expect(w.toString()).to.equal('0xfedcba9876543210');

The last two methods allow you to represent uint64_t values larger than
(1 << 53) - 1.

$3

Int64 exposes toNumber(), valueOf() for converting to numeric values:

var a = new Int64(2),
b = new Int64(3);
expect(a + b).to.equal(5);
var x = new Int64(),
y = new Int64(42),
z = new Int64(0xfedcba98, 0x76543210),
w = new Int64('0xfedcba9876543210')
expect(+x).to.equal(0);
expect(+y).to.equal(42);
expect(+z).to.equal(Infinity);
expect(+w).to.equal(Infinity);

Values larger than (1 << 53) - 1 will be converted to Infinity, since
they cannot be accurately represented using JavaScript's Number type.

As you can see from the examples so far, toString() produces the hex string
corresponding to an Int64.

$3

Int64 also exposes toSignedDecimalString() and toUnsignedDecimalString() for converting to decimal strings:

var minusOne = new Int64('0xFFFFFFFFFFFFFFFF');
expect(minusOne.toSignedDecimalString()).to.equal('-1');
expect(minusOne.toUnsignedDecimalString()).to.equal('18446744073709551615');

$3

For cases where you wish to sort or compare Int64 values, equals() and
compare() are provided:

var a = new Int64(2),
b = new Int64(3);
expect(a.equals(a)).to.be.true;
expect(a.equals(b)).to.be.false;
expect(a.compare(a)).to.equal(0);
expect(a.compare(b)).to.equal(-1);
expect(b.compare(a)).to.equal(1);

$3

There are several operations for bit-level manipulation of Int64 values:

var x = new Int64('0xfedcba9876543210');
expect(x.high32().toString(16)).to.equal('fedcba98');
expect(x.low32().toString(16)).to.equal('76543210');
var y = x.and(new Int64(0xffff)),
z = x.or(new Int64(0xffff)),
w = x.xor(new Int64('fffffffffffffffff'));
expect(y.toString()).to.equal('0x0000000000003210');
expect(z.toString()).to.equal('0xfedcba987654ffff');
expect(w.toString()).to.equal('0x0123456789abcdef');
var a = new Int64(7),
b = a.shiftLeft(1),
c = a.shiftRight(1);
expect(b.toString()).to.equal('0x000000000000000e');
expect(c.toString()).to.equal('0x0000000000000003');