Benchmark: some vs foreach vs flatten

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.11/lodash.min.js"></script>

AخA
 
<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.11/lodash.min.js"></script>

Tests:

foreach

const record = {
    subscriptions: [{
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'wf',
        ],
    }, {
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'wf',
        ],
    }, {
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'wf',
        ],
    }, {
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'aa',
        ],
    }, ],
};
const isSubscribed = (subscriptionRecord, eventType) => {
    const {
        subscriptions
    } = subscriptionRecord;
    const events = [];
    subscriptions.forEach(s => {
        events.push(...s.events);
    });

    return _.includes(events, eventType);
};

const result = isSubscribed(record, 'aa');

​x
 
const record = {    subscriptions: [{        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'wf',        ],    }, {        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'wf',        ],    }, {        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'wf',        ],    }, {        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'aa',        ],    }, ],};const isSubscribed = (subscriptionRecord, eventType) => {    const {        subscriptions    } = subscriptionRecord;    const events = [];    subscriptions.forEach(s => {        events.push(...s.events);    });​    return _.includes(events, eventType);};​const result = isSubscribed(record, 'aa');

flatten

const record = {
    subscriptions: [{
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'wf',
        ],
    }, {
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'wf',
        ],
    }, {
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'wf',
        ],
    }, {
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'aa',
        ],
    }, ],
};
const isSubscribed3 = (subscriptionRecord, eventType) => {
    const events = _.flatten(subscriptionRecord.subscriptions.map(s => s.events))
    return _.includes(events, eventType);
};

const result = isSubscribed3(record, 'aa');

 
const record = {    subscriptions: [{        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'wf',        ],    }, {        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'wf',        ],    }, {        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'wf',        ],    }, {        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'aa',        ],    }, ],};const isSubscribed3 = (subscriptionRecord, eventType) => {    const events = _.flatten(subscriptionRecord.subscriptions.map(s => s.events))    return _.includes(events, eventType);};​const result = isSubscribed3(record, 'aa');

some

const record = {
    subscriptions: [{
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'wf',
        ],
    }, {
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'wf',
        ],
    }, {
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'wf',
        ],
    }, {
        events: [
            'df',
            'ff',
            'gf',
            'hf',
            'rf',
            'aa',
        ],
    }, ],
};
const isSubscribed2 = (subscriptionRecord, eventType) => {
    return _.some(subscriptionRecord.subscriptions, sub => _.includes(sub.events, eventType))
};
const t = isSubscribed2(record, 'aa');

 
const record = {    subscriptions: [{        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'wf',        ],    }, {        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'wf',        ],    }, {        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'wf',        ],    }, {        events: [            'df',            'ff',            'gf',            'hf',            'rf',            'aa',        ],    }, ],};const isSubscribed2 = (subscriptionRecord, eventType) => {    return _.some(subscriptionRecord.subscriptions, sub => _.includes(sub.events, eventType))};const t = isSubscribed2(record, 'aa');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
foreach
flatten
some

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:95.0) Gecko/20100101 Firefox/95.0

Browser/OS: Firefox 95 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
foreach	937347.9 Ops/sec
flatten	1678873.1 Ops/sec
some	1277660.9 Ops/sec

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

Let's dive into the benchmark and explain what's being tested.

Benchmark Overview

The benchmark compares three different approaches to check if an event is subscribed to a subscription record:

forEach
flatten (using Lodash)
some

Options Compared

forEach: uses the forEach method of arrays to iterate over the events in each subscription.
- Pros: simple, straightforward approach.
- Cons: can be slow if the number of events is large, as it requires creating an array and iterating over it.
flatten (using Lodash): uses the flatten function from Lodash to flatten the arrays of events in each subscription.
- Pros: can be faster than forEach, as it avoids creating arrays and iterating over them. Also, Lodash is a popular library with a wide range of utility functions.
- Cons: requires loading an external library (Lodash), which may add overhead.
some: uses the some method of arrays to iterate over the events in each subscription.
- Pros: similar to forEach, but more concise and expressive.
- Cons: same pros and cons as forEach.

Library Used

The benchmark uses Lodash, a popular JavaScript library that provides a wide range of utility functions for tasks such as array manipulation, string manipulation, and more. In this case, the flatten function is used to flatten the arrays of events in each subscription.

Special JS Features or Syntax

None mentioned in the benchmark definition.

Other Considerations

The benchmark uses Firefox 95 as the browser, which may impact the results due to the specific implementation of the browser.
The benchmark measures the executions per second, which is a good metric for measuring performance. However, it's worth noting that this metric can be affected by factors such as CPU frequency and memory usage.

Alternatives

If you're interested in exploring alternative approaches, here are some options:

reduce: instead of using forEach or some, you could use the reduce method to iterate over the events in each subscription.
Custom implementation: if you want to avoid using external libraries like Lodash, you could implement a custom solution using plain JavaScript.

Keep in mind that these alternatives may have different performance characteristics and may require more code to implement.

LLMs can make mistakes. Check important info.

Let's dive into the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares three different approaches to check if an event is subscribed to a subscription record:

1. `forEach`
2. `flatten` (using Lodash)
3. `some`

**Options Compared**

* `forEach`: uses the `forEach` method of arrays to iterate over the events in each subscription.
	+ Pros: simple, straightforward approach.
	+ Cons: can be slow if the number of events is large, as it requires creating an array and iterating over it.
* `flatten` (using Lodash): uses the `flatten` function from Lodash to flatten the arrays of events in each subscription.
	+ Pros: can be faster than `forEach`, as it avoids creating arrays and iterating over them. Also, Lodash is a popular library with a wide range of utility functions.
	+ Cons: requires loading an external library (Lodash), which may add overhead.
* `some`: uses the `some` method of arrays to iterate over the events in each subscription.
	+ Pros: similar to `forEach`, but more concise and expressive.
	+ Cons: same pros and cons as `forEach`.

**Library Used**

The benchmark uses Lodash, a popular JavaScript library that provides a wide range of utility functions for tasks such as array manipulation, string manipulation, and more. In this case, the `flatten` function is used to flatten the arrays of events in each subscription.

**Special JS Features or Syntax**

None mentioned in the benchmark definition.

**Other Considerations**

* The benchmark uses Firefox 95 as the browser, which may impact the results due to the specific implementation of the browser.
* The benchmark measures the executions per second, which is a good metric for measuring performance. However, it's worth noting that this metric can be affected by factors such as CPU frequency and memory usage.

**Alternatives**

If you're interested in exploring alternative approaches, here are some options:

* `reduce`: instead of using `forEach` or `some`, you could use the `reduce` method to iterate over the events in each subscription.
* Custom implementation: if you want to avoid using external libraries like Lodash, you could implement a custom solution using plain JavaScript.

Keep in mind that these alternatives may have different performance characteristics and may require more code to implement.

Related benchmarks:

some vs foreach vs flatten (version: 0)

Comparing performance of: foreach vs flatten vs some

Created: 3 years ago by: Guest

Jump to the latest result