Benchmark: Math.random vs Crypto.getRandomValues for 10k values

Tests:

Math.random
(new Array(10000)).map(function () { return Math.random() })
Crypto.getRandomValues
crypto.getRandomValues(new Uint32Array(10000))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Math.random
Crypto.getRandomValues

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 115 on Android

View result in a separate tab

Test name	Executions per second
Math.random	25125.9 Ops/sec
Crypto.getRandomValues	8101.1 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):

LLMs can make mistakes. Check important info.

I'd be happy to explain the benchmark and its options.

**What is being tested?**

The provided JSON represents a JavaScript microbenchmark that tests two different ways to generate random numbers: `Math.random` and `Crypto.getRandomValues`. The test creates an array of 10,000 values using each method and measures how many times each method can be executed per second (ExecutionsPerSecond).

**Options being compared**

There are two options being compared:

1. **Math.random**: This is a built-in JavaScript function that generates a random number between 0 (inclusive) and 1 (exclusive). It's a simple but relatively slow way to generate random numbers.
2. **Crypto.getRandomValues**: This is an API provided by modern browsers, introduced in HTML5, which allows generating cryptographically secure pseudo-random numbers. It's designed to be faster and more suitable for cryptographic purposes than `Math.random`.

**Pros and Cons of each approach**

1. **Math.random**:
	* Pros: Simple, easy to use, and widely supported.
	* Cons: Relatively slow, not suitable for high-stakes cryptography or simulations requiring low entropy.
2. **Crypto.getRandomValues**:
	* Pros: Faster, more suitable for cryptographic purposes, and provides better randomness properties than `Math.random`.
	* Cons: More complex to use (requires importing the `crypto` module), and may require additional setup for certain browsers.

**Other considerations**

When choosing between these two approaches, consider the specific requirements of your application:

* If you need high-quality random numbers for simulations or cryptography, use `Crypto.getRandomValues`.
* If you only need simple, fast randomness for non-cryptographic purposes (e.g., game development), use `Math.random`.

**Library used in the test**

In this benchmark, the `crypto` library is used to access the `getRandomValues()` function. The `crypto` library provides a range of cryptographic primitives and algorithms, making it suitable for generating cryptographically secure random numbers.

**Special JS feature or syntax**

There is no special JavaScript feature or syntax being tested in this benchmark. Both `Math.random` and `Crypto.getRandomValues` are standard JavaScript APIs.

Related benchmarks:

Math.random vs Crypto.getRandomValues for 10k values (version: 0)

Comparing performance of: Math.random vs Crypto.getRandomValues

Created: 2 years ago by: Guest

Jump to the latest result

Math.random

Crypto.getRandomValues

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months ago):