I am trying to convert a hex string to a BigInt.
I cannot use the default BigInt from node.js where it works just fine since i am using React-native.
I tried using big-integer but i get the error:
Invalid integer
Basic example here: //playcode.io/943259
Displayed is how the native BigInt converts a hex string successfully to a BigInt. Then you can comment out the second part where i import BigInt from big-integer and it will throw the error.
let hexString ='0x9c46e9ec68e9bd4fe1faaba294cba38a71aa177534cdd1b6c7dc0dbd0abd7a7';
console.log['HexString to BigInt', BigInt[hexString]];
//uncomment to get the error
//import BigInt from 'big-integer'
//console.log['HexString to BigInt', BigInt[hexString]];
Andreas
21.1k7 gold badges46 silver badges55 bronze badges
asked Aug 18 at 8:42
5
The package big-integer cannot detect the radix from the string, but you can specify it
import BigInt from 'big-integer'
let hexString ='0x9c46e9ec68e9bd4fe1faaba294cba38a71aa177534cdd1b6c7dc0dbd0abd7a7';
console.log['HexString to BigInt', BigInt[hexString.substring[2], 16]];
answered Aug 18 at 9:02
BobBob
12.3k1 gold badge3 silver badges24 bronze badges
This chapter introduces the concepts, objects and functions used to work with and perform calculations using numbers and dates in JavaScript. This includes using numbers
written in various bases including decimal, binary, and hexadecimal, as well as the use of the global In JavaScript, numbers are implemented in double-precision 64-bit binary format IEEE 754 [i.e., a number between ±2^−1022 and ±2^+1023, or about ±10^−308 to ±10^+308, with a numeric precision of 53 bits]. Integer values
up to ±2^53 − 1 can be represented exactly. In addition to being able to represent floating-point numbers, the number type has three symbolic values: See also JavaScript data types and structures for context with other primitive types in JavaScript. You can use four types of number literals: decimal, binary, octal, and hexadecimal.Math
object to perform a wide variety of mathematical operations on numbers.Numbers
+
Infinity
, -
Infinity
, and
NaN
[not-a-number].Decimal numbers
1234567890
42
// Caution when using leading zeros:
0888 // 888 parsed as decimal
0777 // parsed as octal in non-strict mode [511 in decimal]
Note that decimal literals can start with a zero [0
] followed by another decimal digit, but if every digit after the leading 0
is smaller than 8, the number gets parsed as an octal number.
Binary numbers
Binary number syntax uses a leading zero followed by a lowercase or uppercase Latin letter "B" [0b
or 0B
]. If the digits after the 0b
are not 0 or 1, the following
SyntaxError
is thrown: "Missing binary digits after 0b".
const FLT_SIGNBIT = 0b10000000000000000000000000000000; // 2147483648
const FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
const FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607
Octal numbers
The standard syntax for octal numbers
is to prefix them with 0o
. For example:
There's also a legacy syntax for octal numbers — by prefixing the octal number with a zero: 0644 === 420
and "\045" === "%"
. If the digits after the 0
are outside the range 0 through 7, the number will be interpreted as a decimal number.
const n = 0755; // 493
const m = 0644; // 420
Strict mode forbids this octal syntax.
Hexadecimal numbers
Hexadecimal number syntax uses a leading zero followed by a lowercase or uppercase Latin letter "X" [0x
or 0X
]. If the digits after 0x are outside the range [0123456789ABCDEF], the following
SyntaxError
is thrown: "Identifier starts immediately after numeric literal".
0xFFFFFFFFFFFFFFFFF // 295147905179352830000
0x123456789ABCDEF // 81985529216486900
0XA // 10
Exponentiation
1E3 // 1000
2e6 // 2000000
0.1e2 // 10
Number object
The built-in Number
object has properties for numerical constants, such as maximum value, not-a-number, and infinity. You
cannot change the values of these properties and you use them as follows:
const biggestNum = Number.MAX_VALUE;
const smallestNum = Number.MIN_VALUE;
const infiniteNum = Number.POSITIVE_INFINITY;
const negInfiniteNum = Number.NEGATIVE_INFINITY;
const notANum = Number.NaN;
You always refer to a property of the predefined Number
object as shown above, and not as a property of a Number
object you create yourself.
The following table summarizes the Number
object's properties.
The Number
prototype provides methods for retrieving information from Number
objects in various formats. The following table summarizes the methods of Number.prototype
.
Math object
The built-in Math
object has properties and methods for mathematical constants and functions. For example, the Math
object's
PI
property has the value of pi [3.141…], which you would use in an application as
Similarly, standard mathematical functions are methods of Math
. These include trigonometric, logarithmic, exponential, and other functions. For example, if you want to use the trigonometric function sine, you would write
Note that all trigonometric methods of Math
take arguments in radians.
The following table summarizes the Math
object's methods.
Unlike many other
objects, you never create a Math
object of your own. You always use the built-in Math
object.
BigInts
One shortcoming of number values is they only have 64 bits. In practice, due to using IEEE 754 encoding, they cannot represent any integer larger than
Number.MAX_SAFE_INTEGER
[which is 253 - 1] accurately. To solve the need of encoding binary data and to interoperate with other languages that offer wide integers like i64
[64-bit integers] and i128
[128-bit integers], JavaScript also offers another data type to represent arbitrarily large integers:
BigInt
.
A BigInt can be defined as an integer literal suffixed by n
:
const b1 = 123n;
// Can be arbitrarily large.
const b2 = -1234567890987654321n;
BigInts can also be constructed from number values or string values using the BigInt
constructor.
const b1 = BigInt[123];
// Using a string prevents loss of precision, since long number
// literals don't represent what they seem like.
const b2 = BigInt["-1234567890987654321"];
Conceptually, a BigInt is just an arbitrarily long sequence of bits which encodes an integer. You can safely do any arithmetic operations without losing precision or over-/underflowing.
const integer = 12 ** 34; // 4.9222352429520264e+36; only has limited precision
const bigint = 12n ** 34n; // 4922235242952026704037113243122008064n
Compared to numbers, BigInt values yield higher precision when representing large integers; however, they cannot represent floating-point numbers. For example, division would round to zero:
const bigintDiv = 5n / 2n; // 2n, because there's no 2.5 in BigInt
Math
functions cannot be used on BigInt values. There is
an open proposal to overload certain Math
functions like Math.max[]
to allow BigInt values.
Choosing between BigInt and number depends on your use-case and your input's range. The precision of numbers should be able to accommodate most day-to-day tasks already, and BigInts are most suitable for handling binary data.
Read more about what you can do with BigInt values in the Expressions and Operators section, or the BigInt reference.
Date object
JavaScript does not have a date data type. However, you can use the Date
object and its methods to work with dates and times in your applications. The Date
object has a large number of methods for
setting, getting, and manipulating dates. It does not have any properties.
JavaScript handles dates similarly to Java. The two languages have many of the same date methods, and both languages store dates as the number of milliseconds since January 1, 1970, 00:00:00, with a Unix Timestamp being the number of seconds since January 1, 1970, 00:00:00.
The Date
object range is -100,000,000 days to 100,000,000 days relative to 01 January, 1970 UTC.
To create a Date
object:
const dateObjectName = new Date[[parameters]];
where dateObjectName
is the name of the Date
object being created; it can be a new object or a property of an existing object.
Calling Date
without the new
keyword returns a string representing the current date and time.
The parameters
in the preceding syntax can be any of the following:
- Nothing: creates today's date and time. For example,
today = new Date[];
. - A string representing a date in the following form: "Month day, year
hours:minutes:seconds." For example,
let Xmas95 = new Date["December 25, 1995 13:30:00"]
. If you omit hours, minutes, or seconds, the value will be set to zero. - A set of integer values for year, month, and day. For example,
let Xmas95 = new Date[1995, 11, 25]
. - A set of integer values for year, month, day, hour, minute, and seconds. For example,
let Xmas95 = new Date[1995, 11, 25, 9, 30, 0];
.
Methods of the Date object
The Date
object methods for handling dates and times fall into these broad categories:
- "set" methods, for setting date and time values in
Date
objects. - "get" methods, for getting date and time values from
Date
objects. - "to" methods, for
returning string values from
Date
objects. - parse and UTC methods, for parsing
Date
strings.
With the "get" and "set" methods you can get and set seconds, minutes, hours, day of the month, day of the week, months, and years separately. There is a getDay
method that returns the day of the week, but no corresponding setDay
method, because the day of the week is set automatically. These methods use integers to represent these values as follows:
- Seconds and minutes: 0 to 59
- Hours: 0 to 23
- Day: 0 [Sunday] to 6 [Saturday]
- Date: 1 to 31 [day of the month]
- Months: 0 [January] to 11 [December]
- Year: years since 1900
For example, suppose you define the following date:
const Xmas95 = new Date['December 25, 1995'];
Then Xmas95.getMonth[]
returns 11, and Xmas95.getFullYear[]
returns 1995.
The getTime
and setTime
methods are useful for comparing dates. The getTime
method returns the number of milliseconds since January 1, 1970, 00:00:00 for
a Date
object.
For example, the following code displays the number of days left in the current year:
const today = new Date[];
const endYear = new Date[1995, 11, 31, 23, 59, 59, 999]; // Set day and month
endYear.setFullYear[today.getFullYear[]]; // Set year to this year
const msPerDay = 24 * 60 * 60 * 1000; // Number of milliseconds per day
let daysLeft = [endYear.getTime[] - today.getTime[]] / msPerDay;
daysLeft = Math.round[daysLeft]; //returns days left in the year
This example creates a Date
object named today
that contains today's date. It then creates a Date
object named endYear
and sets the year to the current year. Then, using the number of milliseconds per day, it computes the number of days between today
and endYear
, using getTime
and rounding to a whole number of days.
The parse
method is
useful for assigning values from date strings to existing Date
objects. For example, the following code uses parse
and setTime
to assign a date value to the ipoDate
object:
const ipoDate = new Date[];
ipoDate.setTime[Date.parse['Aug 9, 1995']];
Example
In the following example, the function JSClock[]
returns the
time in the format of a digital clock.
function JSClock[] {
const time = new Date[];
const hour = time.getHours[];
const minute = time.getMinutes[];
const second = time.getSeconds[];
let temp = String[hour % 12];
if [hour === 0]
temp = '12';
temp += [[minute