Socket
Socket
Sign inDemoInstall

node-int64

Package Overview
Dependencies
0
Maintainers
1
Versions
7
Alerts
File Explorer

Advanced tools

Install Socket

Protect your apps from supply chain attacks

Install

node-int64

Support for representing 64-bit integers in JavaScript

    0.4.0latest
    GitHub
    npm

Version published
Maintainers
1
Weekly downloads
17,191,720
decreased by-16.04%

Weekly downloads

Package description

What is node-int64?

The node-int64 npm package is used for handling 64-bit integer values in Node.js. It provides functionality to represent, manipulate, and convert 64-bit integers, which are not natively supported in JavaScript due to its use of IEEE 754 floating-point numbers for all numeric values.

What are node-int64's main functionalities?

Creating 64-bit integers

This feature allows the creation of 64-bit integer instances from various inputs such as number, string, or buffer.

const Int64 = require('node-int64');
const int64 = new Int64('0x1234567890abcdef');

Reading 64-bit integers from buffers

This feature enables reading 64-bit integers directly from buffers, which is useful when dealing with binary data streams.

const Int64 = require('node-int64');
const buffer = Buffer.from('1234567890abcdef', 'hex');
const int64 = new Int64(buffer);

Converting 64-bit integers to strings

This feature allows the conversion of 64-bit integers to their string representation, which can be displayed or stored as text.

const Int64 = require('node-int64');
const int64 = new Int64('0x1234567890abcdef');
const str = int64.toString();

Converting 64-bit integers to native JavaScript numbers

This feature provides the ability to convert 64-bit integers to native JavaScript numbers, with the caveat that precision might be lost for large values.

const Int64 = require('node-int64');
const int64 = new Int64('0x1234567890abcdef');
const num = int64.toNumber();

Other packages similar to node-int64

Readme

Source

JavaScript Numbers are represented as IEEE 754 double-precision floats. Unfortunately, this means they lose integer precision for values beyond +/- 2^^53. For projects that need to accurately handle 64-bit ints, such as node-thrift, a performant, Number-like class is needed. Int64 is that class.

Int64 instances look and feel much like JS-native Numbers. By way of example ...

// First, let's illustrate the problem ...
> (0x123456789).toString(16)
'123456789' // <- what we expect.
> (0x123456789abcdef0).toString(16)
'123456789abcdf00' // <- Ugh!  JS doesn't do big ints. :(

// So let's create a couple Int64s using the above values ...

// Require, of course
> Int64 = require('node-int64')

// x's value is what we expect (the decimal value of 0x123456789)
> x = new Int64(0x123456789)
[Int64 value:4886718345 octets:00 00 00 01 23 45 67 89]

// y's value is Infinity because it's outside the range of integer
// precision.  But that's okay - it's still useful because it's internal
// representation (octets) is what we passed in
> y = new Int64('123456789abcdef0')
[Int64 value:Infinity octets:12 34 56 78 9a bc de f0]

// Let's do some math.  Int64's behave like Numbers.  (Sorry, Int64 isn't
// for doing 64-bit integer arithmetic (yet) - it's just for carrying
// around int64 values
> x + 1
4886718346
> y + 1
Infinity

// Int64 string operations ...
> 'value: ' + x
'value: 4886718345'
> 'value: ' + y
'value: Infinity'
> x.toString(2)
'100100011010001010110011110001001'
> y.toString(2)
'Infinity'

// Use JS's isFinite() method to see if the Int64 value is in the
// integer-precise range of JS values
> isFinite(x)
true
> isFinite(y)
false

// Get an octet string representation.  (Yay, y is what we put in!)
> x.toOctetString()
'0000000123456789'
> y.toOctetString()
'123456789abcdef0'

// Finally, some other ways to create Int64s ...

// Pass hi/lo words
> new Int64(0x12345678, 0x9abcdef0)
[Int64 value:Infinity octets:12 34 56 78 9a bc de f0]

// Pass a Buffer
> new Int64(new Buffer([0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0]))
[Int64 value:Infinity octets:12 34 56 78 9a bc de f0]

// Pass a Buffer and offset
> new Int64(new Buffer([0,0,0,0,0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0]), 4)
[Int64 value:Infinity octets:12 34 56 78 9a bc de f0]

// Pull out into a buffer
> new Int64(new Buffer([0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0])).toBuffer()
<Buffer 12 34 56 78 9a bc de f0>

// Or copy into an existing one (at an offset)
> var buf = new Buffer(1024);
> new Int64(new Buffer([0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0])).copy(buf, 512);

Keywords

FAQs

Last updated on 04 Apr 2015

Did you know?

Socket installs a GitHub app to automatically flag issues on every pull request and report the health of your dependencies. Find out what is inside your node modules and prevent malicious activity before you update the dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc