Benchmark: enabled count - MeasureThat.net

Tests:

set
var rules = [{id: 1, name: 'test1', enabled: false}, {id: 2, name: 'test2', enabled: true}, {id: 3, name: 'test3', enabled: true}, {id: 4, name: 'test4', enabled: true}, {id: 5, name: 'test5', enabled: false}, {id: 6, name: 'test6', enabled: true}, {id: 7, name: 'test7', enabled: false}, {id: 8, name: 'test8', enabled: true}, {id: 9, name: 'test9', enabled: true}, {id: 10, name: 'test10', enabled: true}]; var enabledRuleIds = new Set(rules.reduce((enabledRules, rule) => { if(rule.enabled) { enabledRules.push(rule.id); } return enabledRules; }, []));
loop
var rules = [{id: 1, name: 'test1', enabled: false}, {id: 2, name: 'test2', enabled: true}, {id: 3, name: 'test3', enabled: true}, {id: 4, name: 'test4', enabled: true}, {id: 5, name: 'test5', enabled: false}, {id: 6, name: 'test6', enabled: true}, {id: 7, name: 'test7', enabled: false}, {id: 8, name: 'test8', enabled: true}, {id: 9, name: 'test9', enabled: true}, {id: 10, name: 'test10', enabled: true}]; var enabledRules = rules.filter(r => r.enabled);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
set
loop

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 dive into explaining the provided benchmark.

**Benchmark Overview**

The provided benchmark measures the execution time of two different approaches: using `Set` data structure and a loop to filter enabled rules.

**Approach 1: Using Set Data Structure (Test Name: "set")**

In this approach, an array of objects is created with `rules`. Each object has an `enabled` property. The code then creates a new `Set` instance from the filtered rules using the `reduce()` method and the `if (rule.enabled)` condition.

**Pros:**

* This approach is concise and easy to read.
* It uses built-in JavaScript methods, which are optimized for performance.
* Sets in JavaScript are implemented as hash tables, providing fast lookups and insertions.

**Cons:**

* The implementation might be less intuitive than a traditional loop-based approach for those unfamiliar with `Set` data structures.
* If the input array is very large, creating a new Set instance might incur additional overhead due to memory allocation and garbage collection.

**Approach 2: Using Loop-Based Filtering (Test Name: "loop")**

In this approach, an array of objects is created with `rules`. Each object has an `enabled` property. The code then uses a traditional loop-based approach to filter the rules by iterating over the array and checking the `enabled` property.

**Pros:**

* This approach can be more intuitive for those familiar with loops and conditional statements.
* It avoids potential overhead from creating a new Set instance or using built-in methods that might not be as efficient in this specific case.

**Cons:**

* The implementation is longer and may be less concise than the `Set` based approach.
* Loop-based filtering can lead to more overhead due to repeated checks and iterations over the array.

**Library Used**

In both approaches, the library used is JavaScript's built-in data structures (Arrays) and methods. No external libraries are mentioned in the benchmark definition or test cases.

**Special JS Feature/Syntax**

The `Set` data structure is a built-in feature of JavaScript, but it was introduced in ECMAScript 2015 (ES6). If you're using an older version of JavaScript that doesn't support Sets, this approach might not work as intended.

**Other Alternatives**

If you wanted to explore other approaches, here are a few examples:

* Using `Array.prototype.filter()` instead of a loop-based approach.
* Using `map()` in combination with filtering for an alternative to the Set data structure.
* Comparing different JavaScript engines or implementations, such as V8 (Google Chrome) and SpiderMonkey (Firefox).

Keep in mind that each of these alternatives might introduce additional overhead or have trade-offs in terms of performance, readability, and maintainability.

In conclusion, both approaches have their pros and cons. The `Set` data structure approach is concise and optimized for performance, while the loop-based filtering approach provides more control over the implementation but may incur additional overhead.

Latest run results:

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

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

Browser/OS: Opera 51 on Windows

View result in a separate tab

Test name	Executions per second
set	1191108.5 Ops/sec
loop	7580108.5 Ops/sec

Related benchmarks:

enabled count (version: 0)

Comparing performance of: set vs loop

Created: 6 years ago by: Guest

Jump to the latest result

set

loop

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):