This article is in need of a technical review.

**Draft**

This page is not complete.

As JavaScript doesn't currently include standard support for 64-bit integer values, js-ctypes offers the `Int64`

and `UInt64`

objects to let you work with C functions and data that need (or may need) to use data represented using a 64-bit data type.

You use the `UInt64`

object to create and manipulate 64-bit unsigned integers.

**Note:**It's important to note that the 64-bit integer objects created by

`UInt64`

are not `UInt64`

objects; rather, they're opaque objects whose values you manipulate through the other methods on the `UInt64`

object. See 64-bit integers for details.## Syntax

Creates and returns a new 64-bit unsigned integer.

UInt64 UInt64( value );

###### Parameters

`value`

- The value to assign the new 64-bit unsigned integer object. This may be specified as an integer (if the value can be represented as a 32-bit value), another 64-bit integer object (either signed or unsigned), or as a string, which may consist of an optional minus sign, followed by either a decimal number or "0x" or "0X" followed by a hexadecimal number. The string is then converted into the corresponding 64-bit integer value. You can therefore use a string to represent a 64-bit value that is too large to represent as a 32-bit JavaScript
`Number`

.

###### Return value

A new object representing the specified `value`

.

###### Exceptions thrown

`TypeError`

- The specified value cannot be converted into a 64-bit integer. Either it's not a
`Number`

,`String`

, or 64-bit integer object, or it's a string that is incorrectly formatted or contains a value outside the range that can be represented in 64 bits. This will also be thrown if the source value is a floating-point number that can't be precisely represented as a 64-bit integer.

## Method overview

`Number compare(a, b);` |

`Number hi(a);` |

`UInt64 join(high, low);` |

`Number lo(a);` |

`String toSource([radix]);` |

`String toString();` |

## Methods

### compare()

Compares two 64-bit integer values.

Number compare( a, b );

###### Parameters

`a`

- The first value to compare.
`b`

- The second value to compare.

###### Return value

The returned value is -1 if `a`

<

, 0 if *b*`a`

* == *

, and 1 if *b*`a`

* > *

.*b*

###### Exceptions thrown

`TypeError`

- One or both of the specified values is not a 64-bit integer (either signed or unsigned).

hi()

Returns the high 32 bits of the specified value.

Number hi( num );

###### Parameters

`num`

- The value whose high 32 bits are to be returned.

###### Return value

The high 32 bits of `num`

are returned. This is essentially `num >> 32`

.

###### Exceptions thrown

`TypeError`

`num`

is not a 64-bit integer object.

lo()

Returns the low 32 bits of the specified value.

Number lo( num );

###### Parameters

`num`

- The
`Int64`

value whose low 32 bits are to be returned.

###### Return value

The low 32 bits of `num`

are returned. This is essentially `num & 0xFFFFFFFF`

.

###### Exceptions thrown

`TypeError`

`num`

is not a 64-bit integer object.

join()

Creates a 64-bit integer object with a value constructed using the specified high and low order 32-bit values.

UInt64 join( high, low );

###### Parameters

`high`

- The high-order 32 bits of the value to create.
`low`

- The low-order 32 bits of the value to create.

###### Return value

A new 64-bit integer object comprised of the two values merged together. The returned value is `(high << 32) + low`

.

###### Exceptions thrown

`TypeError`

- One or both of the specified numbers is not a JavaScript number with an integral value.

toSource()

This method is for internal debugging use only.

**Warning:**Do not rely on the value returned by this method, as it's subject to change at any time, depending on the debugging needs of the developers.

toString()

Returns a string representation of the object's numeric value.

String toString( [radix] );

###### Parameters

`radix`

Optional- The radix (base) to use when constructing the string. If you don't specify a radix, base 10 is used.

###### Return value

A string representation of the value in the specified radix. This string consists of a leading minus sign, if the value was negative, followed by one or more lower-case digits in the specified radix.