Benchmark: Recursive Iteration VS. Dynamic RegExp

Script Preparation code:

var parentIds = (new Array(500_000)).map(i => `http://parent/${i}`);
var activeParentIds = parentIds.filter((_, i) => i % 2 === 0);
var pendingChildren = parentIds.reduce((acc, parentId) => ({
    ...acc,
    [parentId + '|A']: true,
    [parentId + '|B']: false,
    [parentId + '|C']: true,
}), {})

Tests:

Recursive Iteration
Object.entries(pendingChildren).some(([childKey, isPending]) => isPending && activeParentIds.some(parentId => childKey.startsWith(parentId + '|')))
Dynamic RegExp
var regex = new RegExp('/^' + activeParentIds.join('|') + '\|') Object.entries(pendingChildren).some(([childKey, isPending]) => isPending && regex.test(childKey))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Recursive Iteration
Dynamic RegExp

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 92 on Windows

View result in a separate tab

Test name	Executions per second
Recursive Iteration	2979200.0 Ops/sec
Dynamic RegExp	1105122.8 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to help you understand the JavaScript microbenchmark provided by MeasureThat.net.

**Benchmark Definition**

The benchmark is designed to compare two approaches: Recursive Iteration and Dynamic RegExp. The test case involves creating an array of URLs for parent IDs, filtering out the active parent IDs, reducing the array to create a mapping of child keys to their respective statuses (A, B, or C), and then iterating through the resulting object to check if each child key matches any active parent ID.

The benchmark definition is represented as JSON, which includes:

* `Name`: A unique identifier for the benchmark.
* `Description`: An optional description of the benchmark (empty in this case).
* `Script Preparation Code`: The JavaScript code that prepares the test data. This code creates an array of 500,000 parent IDs and filters out every other ID to create the activeParentIds array.
* `Html Preparation Code`: An empty string, indicating that no HTML preparation is required.

**Test Cases**

There are two individual test cases:

1. **Recursive Iteration**
The first test case uses the `Object.entries()` method to iterate through the `pendingChildren` object and check if each child key matches any active parent ID using the `some()` method. This approach relies on the inherent performance characteristics of JavaScript objects.
2. **Dynamic RegExp**
The second test case uses a regular expression to match child keys against active parent IDs. The regular expression is created by joining all active parent IDs with a pipe character (`|`) and prefixing each ID with a caret (`^`). This approach relies on the performance characteristics of regular expressions in JavaScript.

**Options Compared**

The two approaches are compared to determine which one performs better:

* **Recursive Iteration**: Uses `Object.entries()` and `some()` methods to iterate through the object.
* **Dynamic RegExp**: Uses a dynamic regular expression to match child keys against active parent IDs.

**Pros and Cons of Each Approach**

1. **Recursive Iteration**
Pros:
	+ Simpler and more readable code
	+ Leverages the performance characteristics of JavaScript objects (e.g., fast lookup times)
Cons:
	+ May be slower for large datasets due to the overhead of object iteration
2. **Dynamic RegExp**
Pros:
	+ Can be faster for large datasets, as regular expressions can take advantage of optimized matching algorithms
Cons:
	+ More complex and harder to read code
	+ Regular expression creation and compilation can introduce additional overhead

**Library and Special JS Feature**

In the Dynamic RegExp test case, the `RegExp` constructor is used to create a new regular expression. This constructor takes a string literal as its first argument, which is the regular expression pattern.

The `join()` method is used to concatenate all active parent IDs with a pipe character (`|`). The resulting string is then prefixed with a caret (`^`) using template literals (the backtick syntax).

**Other Considerations**

When writing microbenchmarks like this one, it's essential to consider the following factors:

* **Input size**: Increasing the input size can reveal performance differences between approaches.
* **Browser and environment variations**: Different browsers and environments may exhibit different performance characteristics for each approach.
* **Code complexity**: While simpler code might be easier to read, over-simplification can lead to reduced performance.

**Alternatives**

If you're interested in exploring alternative approaches or improving the benchmark, consider the following options:

* Use a library like `fast-regex` or `regex-performance`, which provide optimized regular expression matching algorithms.
* Implement a custom iterator using a `Set` data structure instead of relying on `Object.entries()` and `some()`.
* Use a different programming paradigm, such as functional programming with higher-order functions.

Keep in mind that the best approach will depend on your specific use case and requirements. MeasureThat.net provides valuable insights into performance characteristics for various JavaScript approaches.

Related benchmarks:

Recursive Iteration VS. Dynamic RegExp (version: 1)

Comparing performance of: Recursive Iteration vs Dynamic RegExp

Created: 3 years ago by: Registered User

Jump to the latest result

Recursive Iteration

Dynamic RegExp

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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