Benchmark: isNumber: regex vs isNaN vs string comparison (version: 1) vs parseInt 2

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

window.case1 = new Proxy({}, {
    get(t, p, r) {
        if (typeof p === 'string' && !isNaN(p)) {
            return +p
        } else {
            return Reflect.get(t, p, r)
        }
    }
});
window.case2 = new Proxy({}, {
    get(t, p, r) {
        if (/^\d+$/.test(p)) {
            return +p
        } else {
            return Reflect.get(t, p, r)
        }
    }
});
window.case3 = new Proxy({}, {
    get(t, p, r) {
        if (p >= '0' && p <= '9') {
            return +p
        } else {
            return Reflect.get(t, p, r)
        }
    }
});
window.case4 = new Proxy({}, {
    get(t, p, r) {
        try {
            Number.parseInt(p);
            return +p
        } catch (_) {
            return Reflect.get(t, p, r)
        }
    }
});
window.gabage1 = 0;
window.gabage2 = 0;
window.gabage3 = 0;
window.gabage4 = 0;

Tests:

isNaN
gabage1 =+ case1[_.random(0, 1e3, false)];
regex
gabage2 =+ case2[_.random(0, 1e3, false)];
string comparison
gabage3 =+ case3[_.random(0, 1e3, false)];
Number.parseInt
gabage4 =+ case4[_.random(0, 1e3, false)];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
isNaN
regex
string comparison
Number.parseInt

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark is testing four different approaches to check if a string represents a number:

1. `regex` (using a regular expression)
2. `isNaN` (using the built-in `Number.isNaN` function)
3. `string comparison` (a simple string comparison using `>= '0' && p <= '9'`)
4. `Number.parseInt`

**Options Compared**

The benchmark is comparing the performance of these four approaches on a set of random strings that may or may not represent numbers.

* `regex`: uses a regular expression to match a string against a pattern.
* `isNaN`: uses the built-in `Number.isNaN` function to check if a value is NaN (Not a Number).
* `string comparison`: uses a simple string comparison to check if a string starts with '0' and ends with a digit (i.e., a valid number).

**Pros and Cons**

Here's a brief summary of the pros and cons of each approach:

* **regex**: Pros: flexible, can match complex patterns. Cons: slower due to pattern matching, may not work for all edge cases.
* `isNaN`: Pros: fast, simple, widely supported. Cons: may return false positives (e.g., if the string is an empty string), requires `Number` object to be available.
* `string comparison`: Pros: simple, fast, doesn't require `Number` object. Cons: may not work for edge cases (e.g., strings starting with '0' but not ending in a digit).
* `Number.parseInt`: Pros: fast, efficient, can handle non-string inputs. Cons: requires `Number` object to be available, may throw an error if the input is invalid.

**Other Considerations**

The benchmark also includes some additional considerations:

* The use of `Proxy` objects to create a proxy function for each test case. This allows the benchmark to generate random strings and execute the test cases without modifying the original code.
* The inclusion of the Lodash library, which provides the `_random` function used to generate random strings.

**Library**

The Lodash library is used in the benchmark preparation code to provide a way to generate random strings using the `_random` function. This function takes three arguments: a minimum value, a maximum value, and a boolean flag indicating whether to include the maximum value in the range (default is false).

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax used in this benchmark.

Now, let's look at some alternatives:

* **Other regex approaches**: The benchmark uses a simple regular expression (`/^\\d+$/`) to match strings against a pattern. Other approaches might use more complex patterns or techniques (e.g., using `\d` instead of `^\\d+$/`).
* **Using a different comparison function**: Instead of using the built-in `Number.isNaN` function, the benchmark could use a custom comparison function that checks if a value is NaN.
* **Adding additional test cases**: The benchmark currently includes four test cases. Additional test cases might be added to cover more edge cases or scenarios.

Keep in mind that these are just some possible alternatives, and the actual approach used will depend on the specific requirements and goals of the benchmark.

Latest run results:

Run details: (Test run date: 2 years ago)

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

Browser/OS: Chrome 106 on Windows

View result in a separate tab

Test name	Executions per second
isNaN	2526441.8 Ops/sec
regex	2810166.0 Ops/sec
string comparison	2885969.8 Ops/sec
Number.parseInt	2597095.2 Ops/sec

Related benchmarks:

isNumber: regex vs isNaN vs string comparison (version: 1) vs parseInt 2 (version: 0)

another attempt

Comparing performance of: isNaN vs regex vs string comparison vs Number.parseInt

Created: 2 years ago by: Guest

Jump to the latest result

isNaN

regex

string comparison

Number.parseInt

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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