Benchmark: Some vs. Every Includes

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

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)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 days ago)

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

Browser/OS: Chrome 131 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Some (Non-Existing Value)	80878024.0 Ops/sec
Every (Non-Existing Value)	79757032.0 Ops/sec
Some (Existing Value)	97755496.0 Ops/sec
Every (Existing Value)	98460576.0 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 explain the benchmark and its options.

**Benchmark Definition**

The benchmark is designed to compare two approaches:

1. Checking if some members of an array are not equal to a value (`!array.some(value => value === 20);`).
2. Checking if all values in an array are not equal to a value (`array.every(value => value !== 20);`).

**Options Compared**

The benchmark compares the execution time and performance difference between these two approaches.

**Pros and Cons of Each Approach:**

1. **!array.some()**
	* Pros:
		+ More readable code, as it's a common pattern to check if some elements don't match a condition.
		+ Less computations required, as it stops iterating as soon as it finds a non-matching element.
	* Cons:
		+ May not be the most efficient approach, especially for large arrays, since it can lead to unnecessary iterations.
2. **array.every()**
	* Pros:
		+ Can be more efficient than !array.some() for large arrays, since it completes only when all elements match the condition.
		+ Reduces the number of potential false positives compared to !array.some().
	* Cons:
		+ Requires all elements to match the condition, which can lead to a higher number of computations if most elements don't match.

**Library Used**

None explicitly mentioned in the benchmark definition. However, `Array.prototype.every()` is a built-in method that's part of the JavaScript standard library.

**Special JS Feature or Syntax**

The benchmark uses an optional chaining operator (`!`) and arrow functions to define the callback functions for the `some()` and `every()` methods.

For those who might not be familiar:

* The `!` operator is called the "logical NOT" operator. In this context, it's used to negate the result of a conditional expression.
* Arrow functions are a shorthand way to define small, single-expression functions in JavaScript. They're defined using the syntax `(params) => {expression}`.

**Other Alternatives**

If you need to implement this benchmark yourself, here are some alternatives:

1. Using `forEach()` loop: You can write a custom implementation using a `forEach` loop and manual checks for each element.
2. Using `filter()`: Another approach is to use the `filter()` method, which returns a new array with elements that match a condition.

Keep in mind that these alternative implementations might not be as efficient or readable as the original benchmark, but they can serve as an educational exercise to understand how the built-in methods work under the hood.

Related benchmarks:

Some vs. Every 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)

Created: 3 years ago by: Guest

Jump to the latest result

Some (Non-Existing Value)

Every (Non-Existing Value)

Some (Existing Value)

Every (Existing Value)

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