int64-native

    0.5.0 • Public • Published

    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

    via npm

    npm install int64-native
    

    from source

    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
    

    Including

    require() gives you direct access to the constructor:

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

    Constructor

    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.

    Type Conversions

    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.

    Conversion to Decimal String

    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');
    

    Comparison

    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);
    

    Bit Manipulation

    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');
    

    Install

    npm i int64-native

    DownloadsWeekly Downloads

    333

    Version

    0.5.0

    License

    MIT

    Unpacked Size

    22.6 kB

    Total Files

    8

    Last publish

    Collaborators

    • avatar