Benchmark: regex vs loop in keys

Script Preparation code:

var ids = {
    "report_": "1",
    "index_": 1,
    "format_": 1,
    "random_": 1,
    "user_": 1,
    "data_": 1,
    "task_": 1,
    "event_": 1,
    "log_": 1,
    "note_": 1,
    "message_": 1,
    "notification_": 1,
    "order_": 1,
    "product_": 1,
    "transaction_": 1,
    "payment_": 1,
    "invoice_": 1,
    "customer_": 1,
    "account_": 1,
    "profile_": 1
};

Tests:

regex
var keys = [ "report_add", "report_test", "index_1234", "index_random", "format_example", "format_test", "random_abc", "random_123", "user_admin", "user_guest", "data_entry", "data_output", "task_todo", "task_done", "event_start", "event_end", "log_error", "log_warning", "note_personal", "note_public" ]; function getPureKey(key) { if (!key) { return ''; } return key.replace(/_\w+/g, '_'); } keys.forEach(function(k) { const key = getPureKey(k); const contains = ids[key]; });
loop
var keys = [ "report_add", "report_test", "index_1234", "index_random", "format_example", "format_test", "random_abc", "random_123", "user_admin", "user_guest", "data_entry", "data_output", "task_todo", "task_done", "event_start", "event_end", "log_error", "log_warning", "note_personal", "note_public" ]; function isCollectionMemberKey(collectionKey, key) { return key.startsWith(collectionKey) && key.length > collectionKey.length; } keys.forEach(function(k) { let contains = false; for (const collectionKey in ids) { if (isCollectionMemberKey(collectionKey, k)) { contains = true; } } });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
regex
loop

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36

Browser/OS: Chrome 124 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
regex	389265.2 Ops/sec
loop	373624.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

**Benchmark Overview**

The provided benchmark measures the performance of two approaches: regular expressions (regex) and loops, when used to check if certain keys exist in an object (`ids`). The benchmark is designed to identify which approach is faster for this specific task.

**Options Compared**

There are two options being compared:

1. **Regex Approach**: This approach uses a regular expression to match the keys against the `ids` object. The regex pattern is generated dynamically based on the keys in the `keys` array.
2. **Loop Approach**: This approach uses a loop to iterate through each key in the `keys` array and checks if it exists as a key in the `ids` object using the `in` operator.

**Pros and Cons of Each Approach**

**Regex Approach:**

Pros:

* Can be more concise and expressive for complex matching patterns
* Can take advantage of browser's regex engine optimizations

Cons:

* May have performance overhead due to regex parsing and evaluation
* Limited control over iteration order and caching

**Loop Approach:**

Pros:

* Allows for direct access to object properties and potential caching benefits
* More straightforward and easy to understand for simple iterations

Cons:

* May be slower due to the need to iterate through each key individually
* Less concise and more verbose compared to regex patterns

**Library/Functionality Used in Benchmark**

In this benchmark, a custom function `getPureKey` is used in both approaches. This function takes a key as input, removes underscore-sequences (`_\\w+`) using regex substitution, and returns the resulting string. This function is not specifically designed for performance but rather demonstrates the usage of regex patterns.

**Special JS Feature/Syntax**

This benchmark does not explicitly use any special JavaScript features or syntax beyond regular expressions and loops. However, it's worth noting that some modern browsers may optimize certain operations or provide better support for specific features based on their engine version.

**Alternatives**

For similar benchmarks, consider the following alternatives:

* Using `Set` data structures to check membership, which can be faster than traditional object iteration.
* Employing more advanced regex techniques, such as lookaheads or anchoring, which may improve performance but also increase complexity.
* Utilizing just-in-time (JIT) compilation and dynamic compilation for optimal code generation.

By understanding these options and their trade-offs, you can better approach similar benchmarking tasks in the future.

Related benchmarks:

regex vs loop in keys (version: 0)

Comparing performance of: regex vs loop

Created: one year ago by: Guest

Jump to the latest result

regex

loop

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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