Benchmark: Some vs. Includes

Script Preparation code:

var hasZero = [];
var withoutZero = [];
for (var i = 0; i < 10000; i++) {
  hasZero.push(Math.floor(Math.random() * 1000));
  withoutZero.push(Math.floor(Math.random() * 1000) + 1)
}

Tests:

Array.some
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.some(v => v === 0);
Array.includes
var tempResult = !!Math.round(Math.random()) ? hasZero.includes(0) : withoutZero.includes(0);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.some
Array.includes

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 120 on Windows

View result in a separate tab

Test name	Executions per second
Array.some	185281.8 Ops/sec
Array.includes	3525276.2 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 benchmarking test.

**What is tested?**

The benchmark measures the performance difference between two JavaScript methods: `Array.includes()` and `Array.some()`. These methods are used to check if an element exists within an array, but they differ in their approach:

1.  **`Array.includes()`**: This method returns a boolean value indicating whether an element is present in the array. It iterates through the array until it finds the target element or reaches its length.
2.  **`Array.some()`**: This method also returns a boolean value, but it stops iterating as soon as it finds the first element that satisfies the callback condition (in this case, checking if the element is equal to zero). It does not require the array to contain at least one element.

**Comparison of options**

*   **`Array.includes()` vs. `Array.some()`:**
    *   **Pros:**
        *   Both methods are relatively straightforward and easy to understand.
        *   `includes()` may be slightly faster since it only requires a single pass through the array, whereas `some()` iterates until it finds the first matching element or reaches the end of the array.
    *   **Cons:**
        *   The performance difference between these two methods is usually negligible for small to medium-sized arrays. However, as the array size grows, `includes()` might be faster due to its single pass approach.
*   **Using libraries or built-in functions:** Neither of these methods relies on a library or built-in function.

**Special JS feature or syntax**

There are no special JavaScript features or syntax used in this benchmark. The code is straightforward and does not employ any advanced techniques, making it easy for developers to understand and replicate the test.

**Other alternatives**

For checking if an element exists within an array, other methods can be employed:

*   **`Array.prototype.includes()` vs. `Array.prototype.indexOf()`**: These two methods return the index of the first occurrence of the target element or -1 if not found.
*   **Using a custom implementation**: It is possible to implement your own function for checking array elements using loops and conditional statements.

In conclusion, the provided benchmark measures the performance difference between `Array.includes()` and `Array.some()`, focusing on their approaches. Understanding these differences can help developers choose the most suitable method depending on the specific requirements of their application.

Related benchmarks:

Some vs. Includes (version: 0)

Comparing performance of: Array.some vs Array.includes

Created: 3 years ago by: Guest

Jump to the latest result

Array.some

Array.includes

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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