#[repr(transparent)]pub struct JsBigInt(_);
Available on crate feature
napi-6
only.Expand description
The type of JavaScript
BigInt
values.
Example
The following shows an example of adding two numbers that exceed
Number.MAX_SAFE_INTEGER
.
fn add_bigint(mut cx: FunctionContext) -> JsResult<JsBigInt> {
// Get references to the `BigInt` arguments
let a = cx.argument::<JsBigInt>(0)?;
let b = cx.argument::<JsBigInt>(1)?;
// Convert the `BigInt` to `i64`
let a = a.to_i64(&mut cx)
// On failure, convert err to a `RangeError` exception
.or_throw(&mut cx)?;
let b = b.to_i64(&mut cx).or_throw(&mut cx)?;
let sum = a + b;
// Create a `BigInt` from the `i64` sum
Ok(JsBigInt::from_i64(&mut cx, sum))
}
Implementations§
source§impl JsBigInt
impl JsBigInt
pub const POSITIVE: Sign = Sign::Positive
pub const NEGATIVE: Sign = Sign::Negative
sourcepub fn from_digits_le<'cx, C>(
cx: &mut C,
sign: Sign,
digits: &[u64]
) -> Handle<'cx, Self>where
C: Context<'cx>,
pub fn from_digits_le<'cx, C>( cx: &mut C, sign: Sign, digits: &[u64] ) -> Handle<'cx, Self>where C: Context<'cx>,
Creates a BigInt
from a signed magnitude. The BigInt
is calculated as:
Sign * (digit[0] x (2⁶⁴)⁰ + digit[0] x (2⁶⁴)¹ + digit[0] x (2⁶⁴)² ...)
Example
// Creates a `BigInt` equal to `2n ** 128n`
let value: Handle<JsBigInt> = JsBigInt::from_digits_le(
&mut cx,
JsBigInt::POSITIVE,
&[0, 0, 1],
);
sourcepub fn to_i64<'cx, C>(&self, cx: &mut C) -> Result<i64, RangeError<i64>>where
C: Context<'cx>,
pub fn to_i64<'cx, C>(&self, cx: &mut C) -> Result<i64, RangeError<i64>>where C: Context<'cx>,
sourcepub fn to_u64<'cx, C>(&self, cx: &mut C) -> Result<u64, RangeError<u64>>where
C: Context<'cx>,
pub fn to_u64<'cx, C>(&self, cx: &mut C) -> Result<u64, RangeError<u64>>where C: Context<'cx>,
Reads a u64
from a BigInt
.
Fails on overflow or a negative sign.
sourcepub fn to_i128<'cx, C>(&self, cx: &mut C) -> Result<i128, RangeError<i128>>where
C: Context<'cx>,
pub fn to_i128<'cx, C>(&self, cx: &mut C) -> Result<i128, RangeError<i128>>where C: Context<'cx>,
Reads an i128
from a BigInt
.
Fails on overflow and underflow.
sourcepub fn to_u128<'cx, C>(&self, cx: &mut C) -> Result<u128, RangeError<u128>>where
C: Context<'cx>,
pub fn to_u128<'cx, C>(&self, cx: &mut C) -> Result<u128, RangeError<u128>>where C: Context<'cx>,
Reads a u128
from a BigInt
.
Fails on overflow or a negative sign.
sourcepub fn to_digits_le<'cx, C>(&self, cx: &mut C) -> (Sign, Vec<u64>)where
C: Context<'cx>,
pub fn to_digits_le<'cx, C>(&self, cx: &mut C) -> (Sign, Vec<u64>)where C: Context<'cx>,
Gets a signed magnitude pair from a BigInt
.
The BigInt
is calculated as:
Sign * (digit[0] x (2⁶⁴)⁰ + digit[0] x (2⁶⁴)¹ + digit[0] x (2⁶⁴)² ...)
sourcepub fn read_digits_le<'cx, C>(
&self,
cx: &mut C,
digits: &mut [u64]
) -> (Sign, usize)where
C: Context<'cx>,
pub fn read_digits_le<'cx, C>( &self, cx: &mut C, digits: &mut [u64] ) -> (Sign, usize)where C: Context<'cx>,
Gets the sign from a BigInt
and reads digits into a buffer.
The returned usize
is the total number of digits in the BigInt
.
Example
Read a u256
from a BigInt
.
fn bigint_to_u256(cx: &mut FunctionContext, n: Handle<JsBigInt>) -> NeonResult<[u64; 4]> {
let mut digits = [0; 4];
let (sign, num_digits) = n.read_digits_le(cx, &mut digits);
if sign == JsBigInt::NEGATIVE {
return cx.throw_error("Underflow reading u256 from BigInt");
}
if num_digits > digits.len() {
return cx.throw_error("Overflow reading u256 from BigInt");
}
Ok(digits)
}