*js-ctypes*-
## References

**Draft**

This page is not complete.

Because 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) values represented using a 64-bit data type.

You use the `Int64`

object to create and manipulate 64-bit signed integers.

`Int64`

are not `Int64`

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

object. See 64-bit integers for details.Creates and returns a new 64-bit signed integer.

Int64 Int64( value );

`value`

- The value to assign the new 64-bit 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`

.

A new object representing the specified `value`

.

`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.

`Number compare(a, b);` |

`Number hi(a);` |

`Int64 join(high, low);` |

`Number lo(a);` |

`String toSource();` |

`String toString([radix]);` |

Compares two 64-bit integer values.

Number compare( a, b );

`a`

- The first value to compare.
`b`

- The second value to compare.

The returned value is:

**-1** if `a`

<

,*b*

** 0** if `a`

* == *

, and*b*

**1 **if `a`

* > *

.*b*

`TypeError`

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

Returns the high 32 bits of the specified value.

Number hi( num );

`num`

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

The high 32 bits of `num`

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

.

`TypeError`

`num`

is not a 64-bit integer object.

Returns the low 32 bits of the specified value.

Number lo( num );

`num`

- The
`Int64`

value whose low 32 bits are to be returned.

The low 32 bits of `num`

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

.

`TypeError`

`num`

is not a 64-bit integer object.

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

Int64 join( high, low );

`high`

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

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

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

.

`TypeError`

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

This method is for internal debugging use only.

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

String toString( [radix] );

`radix`

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

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.