Benchmark: Some vs. Filter vs. indexOf vs. includes (string version)

Script Preparation code:

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

Tests:

Array.some
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.some(v => v === 0);
Array.filter
var tempResult = !!Math.round(Math.random()) ? hasZero.filter(v => v === 0) : withoutZero.filter(v => v === 0);
Array.indexOf
var tempResult = !!Math.round(Math.random()) ? hasZero.indexOf(0) > -1 : withoutZero.indexOf(0) > -1;
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.filter
Array.indexOf
Array.includes

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:132.0) Gecko/20100101 Firefox/132.0

Browser/OS: Firefox 132 on Ubuntu

View result in a separate tab

Test name	Executions per second
Array.some	9031.9 Ops/sec
Array.filter	9042.5 Ops/sec
Array.indexOf	262060.7 Ops/sec
Array.includes	280841.1 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the provided benchmark.

**Benchmark Overview**

MeasureThat.net is testing the performance of three methods to check if an array contains a specific value: `some()`, `filter()`, and their equivalents using `indexOf()` and `includes()`. The test is comparing these four methods on two arrays with different characteristics: one containing random strings with leading zeros (`hasZero`) and another without (`withoutZero`).

**Methods being compared**

1. **Array.some()**: This method returns `true` if at least one element in the array passes a test (i.e., evaluates to true). It does this by iterating through each element and checking its truthiness.
2. **Array.filter()**: Similar to `some()`, but it returns an array with only the elements that pass the test (i.e., evaluate to true).
3. **Array.indexOf()**: This method returns the index of the first occurrence of a specified value in the array, or -1 if not found.
4. **Array.includes()**: This method returns `true` if at least one element in the array is equal to the specified value.

**Pros and Cons**

*   **some()** and **includes()**:
    *   Pros: simple to understand and implement, can be used for general-purpose checks.
    *   Cons: may not be as efficient as other methods, especially on large arrays or when dealing with null/undefined values.
*   **filter()**: Pros: returns a new array, which is useful for filtering out unwanted data. Cons: creates an additional copy of the original array, which can lead to increased memory usage and slower performance compared to native methods.
*   **indexOf()**:
    *   Pros: efficient for finding a specific value in a small array or when dealing with non-numeric values (e.g., strings).
    *   Cons: may not be suitable for larger arrays or when dealing with numeric values, as it searches the entire array. Additionally, its performance can degrade on edge cases like an empty array.
*   **includes()**:
    + Pros: efficient and concise, returns a boolean value immediately.
    + Cons: has been available in modern browsers since ES6 but was not widely supported until recent years; older browser versions might not support it.

**Libraries and Special Features**

None mentioned in the benchmark definition.

However, if we were to extend this test to consider other methods or libraries, some alternatives could include:

*   **Array.every()**: Another method for checking all elements in an array that pass a test.
*   **Array.includes()` with optional `strict` mode**: This can help differentiate between exact matches and loose string matching (e.g., comparing `"1"` to the actual value of "1").

**Alternatives**

If you wanted to expand this benchmark, other alternatives could include:

*   Using different data structures like Sets or Maps instead of arrays.
*   Incorporating more complex data types like objects or nested arrays.
*   Exploring the performance impact of using `Array.prototype.every()` and `Array.prototype.findIndex()`.
*   Examining how the results compare when using strict modes (e.g., `'use strict'`) versus lax modes.

**Testing Best Practices**

When writing benchmarks, consider the following best practices:

1.  **Representative Test Cases**: Use a diverse set of test cases that cover various scenarios to ensure accurate and reliable results.
2.  **Clear Benchmarking Goals**: Define precise goals for each benchmark (e.g., "How fast can we search an array?" or "What's the most efficient filtering method?").
3.  **Multiple Test Runs**: Perform multiple runs to account for any variations in performance due to factors like hardware, OS, and browser versions.
4.  **Consistency in Testing Environment**: Use a consistent testing environment, including similar hardware configurations, operating systems, and versions of software or libraries.

By carefully crafting benchmarks like this one, developers can gain deeper insights into the performance characteristics of different methods and make informed decisions when choosing between them for their specific use cases.

Related benchmarks:

Some vs. Filter vs. indexOf vs. includes (string version) (version: 0)

Comparing performance of: Array.some vs Array.filter vs Array.indexOf vs Array.includes

Created: one year ago by: Guest

Jump to the latest result

Array.some

Array.filter

Array.indexOf

Array.includes

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