Benchmark: toBase62String - MeasureThat.net

Script Preparation code:

	function toBase62String1(value) {
	    if (!value) {
	        return value.toString();
	    }
	    const base = 62n;
	    const digits = [
	        "0", "1", "2", "3", "4", "5", "6", "7",
	        "8", "9", "a", "b", "c", "d", "e", "f",
	        "g", "h", "i", "j", "k", "l", "m", "n",
	        "o", "p", "q", "r", "s", "t", "u", "v",
	        "w", "x", "y", "z", "A", "B", "C", "D",
	        "E", "F", "G", "H", "I", "J", "K", "L",
	        "M", "N", "O", "P", "Q", "R", "S", "T",
	        "U", "V", "W", "X", "Y", "Z"
	    ];
	    const remainders = [];
	    const sign = value < 0n ? "-" : "";
	    let quotient = sign ? 0n - value : value;
	    do {
	        remainders.unshift(digits[Number(quotient % base)]);
	        quotient /= base;
	    } while (quotient);
	    return `${sign}${remainders.join("")}`;
	}

	function toBase62String2(value) {
	    if (!value) {
	        return value.toString();
	    }
	    const base = 62n;
	    const digits = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
	    const sign = value < 0n ? "-" : "";
	    let quotient = sign ? 0n - value : value;
	    let result = "";
	    do {
	        result = `${digits[Number(quotient % base)]}${result}`;
	        quotient /= base;
	    } while (quotient);
	    return `${sign}${result}`;
	}

	function getRandomIdString1(steps = 4) {
	    let seed = "";
	    for (let i = 0; i < steps; i++) {
	        seed += Math.random().toString().substring(2);
	    }
	    return toBase62String1(BigInt(seed));
	};

	function getRandomIdString2(steps = 4) {
	    let seed = "";
	    for (let i = 0; i < steps; i++) {
	        seed += Math.random().toString().substring(2);
	    }
	    return toBase62String2(BigInt(seed));
	};

​x
 
    function toBase62String1(value) {        if (!value) {            return value.toString();        }        const base = 62n;        const digits = [            "0", "1", "2", "3", "4", "5", "6", "7",            "8", "9", "a", "b", "c", "d", "e", "f",            "g", "h", "i", "j", "k", "l", "m", "n",            "o", "p", "q", "r", "s", "t", "u", "v",            "w", "x", "y", "z", "A", "B", "C", "D",            "E", "F", "G", "H", "I", "J", "K", "L",            "M", "N", "O", "P", "Q", "R", "S", "T",            "U", "V", "W", "X", "Y", "Z"        ];        const remainders = [];        const sign = value < 0n ? "-" : "";        let quotient = sign ? 0n - value : value;        do {            remainders.unshift(digits[Number(quotient % base)]);            quotient /= base;        } while (quotient);        return `${sign}${remainders.join("")}`;    }​    function toBase62String2(value) {        if (!value) {            return value.toString();        }        const base = 62n;        const digits = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";        const sign = value < 0n ? "-" : "";        let quotient = sign ? 0n - value : value;        let result = "";        do {            result = `${digits[Number(quotient % base)]}${result}`;            quotient /= base;        } while (quotient);        return `${sign}${result}`;    }​    function getRandomIdString1(steps = 4) {        let seed = "";        for (let i = 0; i < steps; i++) {            seed += Math.random().toString().substring(2);        }        return toBase62String1(BigInt(seed));    };​    function getRandomIdString2(steps = 4) {        let seed = "";        for (let i = 0; i < steps; i++) {            seed += Math.random().toString().substring(2);        }        return toBase62String2(BigInt(seed));    };

Tests:

Array Version
getRandomIdString1()
getRandomIdString1()
String Version
getRandomIdString2()
getRandomIdString2()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Array Version
String Version

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
Array Version	38835.8 Ops/sec
String Version	48588.9 Ops/sec

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

Let's break down the provided benchmark and explain what is being tested.

Benchmark Definition

The benchmark defines two functions: toBase62String1 and toBase62String2, both of which convert a BigInt value to a base-62 string. Additionally, two test cases are defined: getRandomIdString1 and getRandomIdString2. These test cases generate random IDs as strings using the toBase62String functions.

Options Compared

The benchmark compares two implementations of the toBase62String function:

toBase62String1: This implementation uses a constant array of base-62 digits and performs division and modulo operations to convert the BigInt value to a string.
toBase62String2: This implementation uses a single string containing all base-62 digits, allowing for direct indexing to retrieve the correct digit.

Pros and Cons

toBase62String1:
- Pros: Uses a constant array, which might be more efficient in terms of memory usage.
- Cons: Requires explicit division and modulo operations, which could lead to slower performance compared to using direct indexing.
toBase62String2:
- Pros: Allows for direct indexing, potentially leading to faster performance due to reduced overhead.
- Cons: Uses a larger string containing all base-62 digits, which might increase memory usage.

Library and Special JS Features

BigInt: The BigInt class is used in both implementations to represent BigInt values. This feature was introduced in ECMAScript 2019 (ES2020) as part of the JavaScript standard.
Math.random(): Both test cases use Math.random() to generate random numbers for seed generation.

Other Considerations

The benchmark measures the performance of these two implementations, comparing their execution speed and number of executions per second. This allows users to determine which implementation is faster and more suitable for their specific use case.

Alternatives

If you're looking for alternatives or modifications to these implementations, here are a few options:

Use a library: Consider using a dedicated library like base62 (a Node.js module) or implementing a base-62 conversion function from scratch.
Optimize individual components: Focus on optimizing specific parts of the implementation, such as reducing memory allocation for the string array in toBase62String1.
Test with different inputs: Test the implementations with various input sizes and types (e.g., large integers, strings) to ensure their performance characteristics hold up.

Keep in mind that these alternatives might not provide significant improvements over the existing implementations but can help you explore different design choices and optimizations.

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what is being tested.

**Benchmark Definition**

The benchmark defines two functions: `toBase62String1` and `toBase62String2`, both of which convert a BigInt value to a base-62 string. Additionally, two test cases are defined: `getRandomIdString1` and `getRandomIdString2`. These test cases generate random IDs as strings using the `toBase62String` functions.

**Options Compared**

The benchmark compares two implementations of the `toBase62String` function:

1. **`toBase62String1`**: This implementation uses a constant array of base-62 digits and performs division and modulo operations to convert the BigInt value to a string.
2. **`toBase62String2`**: This implementation uses a single string containing all base-62 digits, allowing for direct indexing to retrieve the correct digit.

**Pros and Cons**

1. **`toBase62String1`**:
	* Pros: Uses a constant array, which might be more efficient in terms of memory usage.
	* Cons: Requires explicit division and modulo operations, which could lead to slower performance compared to using direct indexing.
2. **`toBase62String2`**:
	* Pros: Allows for direct indexing, potentially leading to faster performance due to reduced overhead.
	* Cons: Uses a larger string containing all base-62 digits, which might increase memory usage.

**Library and Special JS Features**

1. **BigInt**: The `BigInt` class is used in both implementations to represent BigInt values. This feature was introduced in ECMAScript 2019 (ES2020) as part of the JavaScript standard.
2. **Math.random()**: Both test cases use `Math.random()` to generate random numbers for seed generation.

**Other Considerations**

**Alternatives**

If you're looking for alternatives or modifications to these implementations, here are a few options:

1. **Use a library**: Consider using a dedicated library like `base62` (a Node.js module) or implementing a base-62 conversion function from scratch.
2. **Optimize individual components**: Focus on optimizing specific parts of the implementation, such as reducing memory allocation for the string array in `toBase62String1`.
3. **Test with different inputs**: Test the implementations with various input sizes and types (e.g., large integers, strings) to ensure their performance characteristics hold up.

Keep in mind that these alternatives might not provide significant improvements over the existing implementations but can help you explore different design choices and optimizations.

Related benchmarks:

toBase62String (version: 0)

Comparing performance of: Array Version vs String Version

Created: one year ago by: Guest

Jump to the latest result

Array Version

String Version

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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