Benchmark: Date JsonReviver8

Script Preparation code:

var input = [];

for (i = 2; i <= 100000; i++) {
    const date = new Date(Math.random()*1000);
  
    const value = i % 2 === 0 ? date.toISOString() : 'some random value';
    const key = i % 2 === 0 ? 'businessDate' : 'some random key';
  
    input.push({
        key,
        value
    });
  
    input.push({
        key: 'index',
        value: i
    });
  
  input.push({
        key: 'updatedAt',
        value: i
    });
  
  input.push({
        key: 'a',
        value: Math.random()
    });
  
  input.push({
        key: 'b',
        value: Math.random()
    });
  
    input.push({
        key: 'c',
        value: Math.random()
    });
  
  input.push({
        key: 'd',
        value: Math.random()
    });
  
  input.push({
        key: 'e',
        value: Math.random()
    });
}

Tests:

Baseline
const result = input.map(x=>{ if (typeof x.value !== 'string') { return x.value; } switch (x.key) { case 'businessDate': case 'startDate': case 'endDate': case 'createdAt': case 'updatedAt': return new Date(x.value); default: return x.value; } });
Regex
const result = input.map(x=>{ if (typeof x.value !== 'string') { return x.value; } switch (x.key) { case 'businessDate': case 'startDate': case 'endDate': if (/(\d{4})-(\d{2})-(\d{2})/.test(x.value)) { return new Date(x.value + 'T00:00:00.000'); } return new Date(x.value); case 'createdAt': case 'updatedAt': return new Date(x.value); default: return x.value; } });
No check
const result = input.map(x=>{ if (typeof x.value !== 'string') { return x.value; } switch (x.key) { case 'businessDate': case 'startDate': case 'endDate': return new Date(x.value + 'T00:00:00.000'); case 'createdAt': case 'updatedAt': return new Date(x.value); default: return x.value; } });
Length
const result = input.map(x=>{ if (typeof x.value !== 'string') { return x.value; } switch (x.key) { case 'businessDate': case 'startDate': case 'endDate': if (x.value.length === 10) { return new Date(x.value + 'T00:00:00.000'); } return new Date(x.value); case 'createdAt': case 'updatedAt': return new Date(x.value); default: return x.value; } });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Baseline
Regex
No check
Length

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down what is being tested in the provided JSON benchmark.

The test case involves creating an array of objects with various key-value pairs, including dates and numbers. The goal is to measure how quickly different JavaScript engines can iterate over this array and perform operations on its elements.

**Options being compared:**

1. **Baseline**: This option checks if the value is a string using `typeof x.value !== 'string'`. It then performs a simple switch statement to determine which date format to use.
2. **Regex**: This option uses a regular expression (`/(\\d{4})-(\\d{2})-(\\d{2})/.test(x.value)`) to check if the value is in the ISO 8601 date format (YYYY-MM-DDTHH:MM:SS.SSSZ). If it matches, it converts the string to a Date object.
3. **No check**: This option skips the `typeof` check and directly uses the `switch` statement to convert dates to Date objects based on their keys.
4. **Length**: This option checks if the length of the value is exactly 10 characters (e.g., for ISO 8601 dates). If it matches, it converts the string to a Date object.

**Pros and cons of each approach:**

* **Baseline**: Pros: simple and efficient; Cons: may not handle all date formats correctly. If the engine can't determine the format from the key, it will default to the `default` branch, which might be slower.
* **Regex**: Pros: robust and flexible; Cons: regular expressions can be computationally expensive and may introduce unnecessary overhead. The engine must also compile the regex pattern, which can add latency.
* **No check**: Pros: simple and fast; Cons: assumes that all dates are in a specific format (based on the key), which might not always be the case.
* **Length**: Pros: efficient for ISO 8601 dates; Cons: may not handle other date formats correctly.

**Browser-specific results:**

The latest benchmark result shows performance variations across different browsers and environments:

* Chrome 99 performs well in all options ( Baseline, Regex, No check, Length).
* The `Length` option outperforms the others by a small margin.
* The `Baseline` option comes closest to the other options.

**Conclusion:**

The benchmark highlights the importance of correctly handling date formats and regular expressions in JavaScript engines. While each approach has its pros and cons, the best-performing option is **Length**, which leverages the efficient compilation and execution of regex patterns for ISO 8601 dates. However, it's essential to consider other factors like code maintainability, flexibility, and potential errors when choosing a solution.

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/99.0.4844.84 Safari/537.36

Browser/OS: Chrome 99 on Windows

View result in a separate tab

Test name	Executions per second
Baseline	31.2 Ops/sec
Regex	27.8 Ops/sec
No check	29.9 Ops/sec
Length	31.5 Ops/sec

Related benchmarks:

Date JsonReviver8 (version: 0)

Comparing performance of: Baseline vs Regex vs No check vs Length

Created: 2 years ago by: Guest

Jump to the latest result

Baseline

Regex

No check

Length

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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