Toggle navigation
MeasureThat
.net
Create a benchmark
Tools
Feedback
Feature Requests
FAQ
Register
Log In
JS BigInt big number performance v8
(version: 0)
Benchmark.js
Compare Number vs BigInt for big numbers
Comparing performance of:
BigInt vs Number
Created:
3 years ago
by:
Guest
Go to the latest result
Tests:
BigInt
let n = 0n for (let i = 0n; i < 5n; i++) { n += i }
Number
let n = 0 for (let i = 0; i < 5; i++) { n += i }
Rendered benchmark preparation results:
Suite status:
<idle, ready to run>
Run tests (2)
Previous results
Fork
Test case name
Result
BigInt
Number
Fastest:
N/A
Slowest:
N/A
Latest run results:
Run details:
(Test run date:
21 days ago
)
User agent:
Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36
Browser/OS:
Chrome 152 on Mac OS X 10.15.7
View result in a separate tab
Embed
Embed Benchmark Result
<iframe src="https://measurethat.net/Embed?id=633867" width="100%" height="500px"></iframe>
Number
156.8M/s
BigInt
13.8M/s
View exact numbers
Test name
Executions per second
✓
Number
156,789,664 Ops/sec
BigInt
13,760,454 Ops/sec
Autogenerated LLM Summary
(model
llama3.2:3b
, generated one year ago):
I'd be happy to explain the test being performed in this benchmark. **Benchmark Definition** The test compares the performance of two approaches for handling large numbers: `Number` and `BigInt`. **Options Compared** The two options being compared are: 1. **Number**: This is a built-in JavaScript type that represents a decimal number with a fixed precision, usually 53 bits in modern browsers. However, it can cause performance issues when dealing with very large numbers due to limitations in its arithmetic operations. 2. **BigInt**: This is a relatively new addition to the ECMAScript standard (introduced in ES2020) designed specifically for handling arbitrarily large integers. It provides support for arbitrary-precision arithmetic and is generally more efficient than `Number` for large numbers. **Pros and Cons** Using `Number`: * Pros: + Smaller memory footprint + Can be faster for certain operations (e.g., basic arithmetic) * Cons: + Can cause performance issues with very large numbers due to integer overflows and limitations in arithmetic operations. + May not support all mathematical operations (e.g., modular exponentiation). Using `BigInt`: * Pros: + Designed specifically for handling arbitrarily large integers, providing efficient arithmetic operations. + Supports a wider range of mathematical operations. * Cons: + Larger memory footprint + Can be slower than `Number` for certain operations **Library and Purpose** In this benchmark, there is no library explicitly mentioned. However, it's worth noting that the `BigInt` type relies on the `BigInt64Array` (or `BigUint64Array` for unsigned integers) to perform arithmetic operations. **Special JS Feature or Syntax** There are no special JavaScript features or syntax being tested in this benchmark. The code snippets provided only demonstrate simple arithmetic operations with large numbers. **Other Alternatives** If you need to handle very large numbers, other alternatives could include: 1. **GMP (Gaussian Multiplication-Modular) libraries**: These libraries provide support for arbitrary-precision arithmetic and can be used in conjunction with JavaScript. 2. **Library-based solutions**: Libraries like `mathjs` or `decimal.js` provide support for decimal arithmetic and may offer more control over performance than the built-in `Number` and `BigInt` types. Keep in mind that these alternatives might require more code and setup, but can provide more flexibility and control over performance. Let me know if you have any further questions!
Related benchmarks
JS BigInt multiply vs addition
BigInt vs ParseInt
JS BigInt big number performance vx4
bignumber.js vs native benchmark: compareTo
parseInt vs Number BigInts
Comments
Confirm delete:
Do you really want to delete benchmark?