Benchmark: UUID V4 Crypto vs Math

Script Preparation code:

function uuidCrypto() {
  let bytes = window.crypto.getRandomValues(new Uint8Array(32));
  const randomBytes = () => (bytes = bytes.slice(1)) && bytes[0];

  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => (c ^ randomBytes() & 15 >> c / 4).toString(16))
}

function uuidMath() {
				return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
					const r = (Math.random() * 16) | 0;
					const v = c === 'x' ? r : (r & 0x3) | 0x8;
					return v.toString(16);
				});
}

function uuidCryptoNumber() {
  let bytes = window.crypto.getRandomValues(new Uint8Array(32));
  const randomBytes = () => (bytes = bytes.slice(1)) && bytes[0];

  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, c => 
      (c ^ randomBytes() & 15 >> c / 4).toString(16)
    );
}

Tests:

math
uuidMath()
crypto
uuidCrypto()
crypto Number to String
uuidCryptoNumber()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
math
crypto
crypto Number to String

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided JSON represents a JavaScript microbenchmark, specifically comparing the performance of three different approaches for generating Universally Unique Identifiers (UUIDs) in JavaScript:

1. **`uuidMath()`**: This function uses `Math.random()` to generate random numbers and then constructs a UUID string by replacing hexadecimal characters with values generated from `Math.random()`.
2. **`uuidCrypto()`**: This function uses the Web Cryptography API (`window.crypto`) to generate cryptographically secure random bytes, which are then sliced and shifted to create a UUID string.
3. **`uuidCryptoNumber()`**: This function generates a UUID string by replacing hexadecimal characters with values generated from `Math.random()`, similar to `uuidMath()`, but uses a specific format to match the required UUID structure.

**Comparison of Options**

The benchmark compares the performance of these three approaches:

* **`uuidMath()`**: Simple and fast, but may not be suitable for cryptographic purposes due to the use of non-cryptographically secure random numbers.
* **`uuidCrypto()`**: Provides cryptographically secure randomness, which is essential for generating unique IDs that can be used for security purposes. However, it may be slower than `uuidMath()` due to the overhead of Web Cryptography API operations.
* **`uuidCryptoNumber()`**: A hybrid approach that combines the speed of `uuidMath()` with the cryptographic security of `uuidCrypto()`. It uses a specific format to match the required UUID structure.

**Pros and Cons**

| Approach | Pros | Cons |
| --- | --- | --- |
| `uuidMath()` | Fast, simple | Not suitable for cryptography |
| `uuidCrypto()` | Cryptographically secure | Slower than `uuidMath()` |
| `uuidCryptoNumber()` | Balances speed and security | May have performance overhead due to formatting |

**Library and Purpose**

The Web Cryptography API (`window.crypto`) is used in `uuidCrypto()`, which provides a way to generate cryptographically secure random numbers for use in cryptographic algorithms, such as generating UUIDs.

**Special JS Features/Syntax**

This benchmark does not specifically utilize any special JavaScript features or syntax beyond what is typically available in modern JavaScript engines. However, it relies on the Web Cryptography API, which may require specific configuration and setup to work correctly.

**Alternatives**

Other alternatives for generating UUIDs in JavaScript include:

* Using a library like `uuid.js`, which provides a simple and efficient way to generate UUIDs.
* Using a random number generator algorithm that is not part of the Web Cryptography API, such as the `crypto.randomBytes()` method on Node.js.

Note that these alternatives may have different trade-offs in terms of performance, security, and simplicity compared to the approaches used in this benchmark.

Latest run results:

Run details: (Test run date: 22 hours ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0.1 Safari/605.1.15

Browser/OS: Safari 18 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
math	831353.6 Ops/sec
crypto	302408.0 Ops/sec
crypto Number to String	289041.7 Ops/sec

Related benchmarks:

UUID V4 Crypto vs Math (version: 0)

Crypto.getRandomValues vs Math.random

Comparing performance of: math vs crypto vs crypto Number to String

Created: 4 years ago by: Guest

Jump to the latest result

math

crypto

crypto Number to String

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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