Benchmark: random id gen - MeasureThat.net

Script Preparation code:

function nanoid(t = 21) {
    crypto.getRandomValues(new Uint8Array(t)).reduce(((t, e) => t += (e &= 63) < 36 ? e.toString(36) : e < 62 ? (e - 26).toString(36).toUpperCase() : e < 63 ? "_" : "-"), "");
}

function generateCode(length, containUppercase, groups = 0) {
    let result = '';
    let characters = containUppercase ? 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' : 'abcdefghijklmnopqrstuvwxyz';
    let charactersLength = characters.length;

    for (let i = 0; i < length; i++) {
        result += characters.charAt(Math.floor(Math.random() * charactersLength));
    }

    if (groups) result = result.split('').map((l, i, a) => (i + 1) % groups == 0 && i != a.length - 1 ? l + '-' : l).join('')

    return result;
}

Tests:

nanoid
for (let i = 0; i < 100000; i++) { nanoid(); }
generatecode
for (let i = 0; i < 100000; i++) { generateCode(21, true); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
nanoid
generatecode

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'll explain the provided benchmark in detail.

**Benchmark Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided benchmark definition and test cases measure the execution time of two different functions: `nanoid` and `generateCode`.

**Function Explanation**

1. **`nanoid` function**: This function generates a random ID using the `crypto.getRandomValues` API, which is part of the Web Cryptography API. It takes an optional argument `t`, which specifies the length of the generated ID (default value is 21). The function uses bitwise operations to concatenate hexadecimal digits to create a random ID.
2. **`generateCode` function**: This function generates a randomly generated string with a specified length and optionally contains uppercase letters. The function takes three arguments: `length`, `containUppercase`, and `groups`. The `length` argument specifies the number of characters in the generated string, while `containUppercase` is a boolean flag that enables or disables the use of uppercase letters. The `groups` argument (default value is 0) allows for grouping consecutive characters with a specific separator.

**Benchmark Comparison**

The provided benchmark compares the execution time of two test cases:

1. **`nanoid`**: This test case measures the execution time of calling the `nanoid` function 100,000 times.
2. **`generateCode(21, true)`**: This test case measures the execution time of calling the `generateCode` function with a length of 21 and containing uppercase letters (i.e., `containUppercase` is set to `true`). The test case generates 100,000 strings using this specific configuration.

**Options Compared**

The benchmark compares two different approaches:

1. **`nanoid`**: This approach uses the Web Cryptography API (`crypto.getRandomValues`) to generate random numbers.
2. **`generateCode(21, true)`**: This approach uses a custom function to generate a randomly generated string with a specified length and optional uppercase letters.

**Pros and Cons of Each Approach**

1. **`nanoid`**:
	* Pros: Uses the Web Cryptography API, which provides a secure way to generate random numbers.
	* Cons: May be slower than other approaches due to its cryptographic overhead.
2. **`generateCode(21, true)`**:
	* Pros: Can potentially produce faster results since it doesn't rely on cryptographic functions.
	* Cons: Uses a custom function that might not be optimized for performance.

**Library and Special JS Features**

In this benchmark, the `crypto.getRandomValues` API is used to generate random numbers. This API is part of the Web Cryptography API and provides a secure way to generate cryptographically strong random numbers.

No special JavaScript features or syntax are mentioned in the benchmark definition.

**Alternative Approaches**

Other possible approaches to generating random IDs or strings include:

1. **Math.random()**: Using the `Math.random()` function to generate random numbers.
2. **Random number generators libraries**: Utilizing external libraries like `random-seed` or `rand()` that provide fast and efficient random number generation.
3. **Hash functions**: Using hash functions like SHA-256 or MD5 to generate a fixed-size string.

Keep in mind that these alternatives might have different performance characteristics, security implications, and code complexity compared to the approaches used in the benchmark.

Latest run results:

Run details: (Test run date: 4 months ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Windows

View result in a separate tab

Test name	Executions per second
nanoid	5.1 Ops/sec
generatecode	2.9 Ops/sec

Related benchmarks:

random id gen (version: 0)

Comparing performance of: nanoid vs generatecode

Created: 2 years ago by: Guest

Jump to the latest result

nanoid

generatecode

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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