Benchmark: Some vs. Every vs Includes

Some vs. Every vs Includes (version: 0)

Check if NOT some members of an array equal a value vs. checking if all values in an array aren't equal to a value.

Comparing performance of: `Some (Non-Existing Value) vs Every (Non-Existing Value) vs Some (Existing Value) vs Every (Existing Value) vs Includes (Non-Existing Value) vs Includes (Existing Value)`

Created: 2 years ago by: Guest

Go to the latest result

Script Preparation code:

var array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];

Tests:

Some (Non-Existing Value)
!array.some(value => value === 20);
Every (Non-Existing Value)
array.every(value => value !== 20);
Some (Existing Value)
!array.some(value => value === 10);
Every (Existing Value)
array.every(value => value !== 10);
Includes (Non-Existing Value)
array.includes(20);
Includes (Existing Value)
array.includes(10);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Some (Non-Existing Value)
Every (Non-Existing Value)
Some (Existing Value)
Every (Existing Value)
Includes (Non-Existing Value)
Includes (Existing Value)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years 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

Includes (Existing Value)

30.0M/s

Includes (Non-Existing Value)

29.9M/s

Some (Existing Value)

26.8M/s

Every (Existing Value)

26.7M/s

Some (Non-Existing Value)

25.5M/s

Every (Non-Existing Value)

25.3M/s

View exact numbers

Test name	Executions per second
✓ Includes (Existing Value)	29,980,248 Ops/sec
Includes (Non-Existing Value)	29,923,958 Ops/sec
Some (Existing Value)	26,808,366 Ops/sec
Every (Existing Value)	26,697,886 Ops/sec
Some (Non-Existing Value)	25,456,060 Ops/sec
Every (Non-Existing Value)	25,318,862 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark and explain what's being tested, along with their pros and cons.

**Benchmark Purpose**

The goal of this benchmark is to compare the performance of three different methods:

1. `some()`: Returns `true` if at least one element in an array satisfies a condition.
2. `every()`: Returns `true` if all elements in an array satisfy a condition.
3. `includes()` (introduced in ECMAScript 2019): Returns `true` if the array includes a specific value.

**Options Compared**

* `some(value => value === 20)`: This method checks if any element in the array is equal to 20. However, since there's no 20 in the array, this condition will always be false.
* `array.every(value => value !== 10)`: This method checks if all elements in the array are not equal to 10. Since most elements are greater than 10 and only a few are less than or equal to 10, this condition will be true for some arrays but false for others.
* `array.includes(20)`: This method checks if the array includes a specific value (in this case, 20). Again, since there's no 20 in the array, this condition will always be false.
* `array.includes(10)`: Similar to the previous point, this method checks if the array includes a specific value (in this case, 10).

**Pros and Cons**

* `some()`
	+ Pros: Can be faster for large arrays because it stops as soon as it finds one match.
	+ Cons: May return false positives if there's at least one element that matches the condition, even if not all elements do.
* `every()`
	+ Pros: Returns a clear result (true or false) and can be used to check if all elements meet a certain condition. Can be faster for large arrays because it stops as soon as it finds an element that doesn't match.
	+ Cons: May return false negatives if there's at least one element that doesn't match the condition, even if most elements do.
* `includes()`
	+ Pros: Returns a clear result (true or false) and can be faster for large arrays because it stops as soon as it finds the target value.
	+ Cons: Can return false positives if there's no duplicate of the target value in the array.

**Library**

The benchmark doesn't use any specific library besides JavaScript core features. However, `includes()` is a part of the ECMAScript 2019 standard and has been supported by most modern browsers for a while.

**Special JS Feature or Syntax**

There are no special JavaScript features or syntax used in this benchmark other than the new `includes()` method introduced in ECMAScript 2019.