Benchmark: Some vs. Filter vs. indexOf vs. Includes vs. Find in Object

Script Preparation code:

var array = [];
for (var i = 0; i < 10000; i++) {
  array.push({value: { value: Math.floor(Math.random() * 1000)}});
}
array.push({value: { value: 42}});

Tests:

Array.some
var tempResult = array.some(v => v.value.value === 42)
Array.filter
var tempResult = array.filter(v => v.value.value === 42);
Array.indexOf
var tempResult = array.indexOf({value: {value: 42}}) > -1;
Array.includes
var tempResult = array.includes(v => v.value.value === 42);
Array.find
var tempResult = array.find(v => v.value.value === 42);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.some
Array.filter
Array.indexOf
Array.includes
Array.find

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/122.0.0.0 Safari/537.36 Edg/122.0.0.0

Browser/OS: Chrome 122 on Windows

View result in a separate tab

Array.includes

9.1M/s

Array.some

2.1M/s

Array.find

1.1M/s

Array.indexOf

195K/s

Array.filter

22K/s

View exact numbers

Test name	Executions per second
✓ Array.includes	9,053,109 Ops/sec
Array.some	2,136,128 Ops/sec
Array.find	1,116,909 Ops/sec
Array.indexOf	194,630 Ops/sec
Array.filter	21,675 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

The provided benchmark compares four different methods for searching for a value within an array in JavaScript:

1. `some()`
2. `filter()`
3. `indexOf()`
4. `includes()` (new in ECMAScript 2019)

**Options Compared:**

*   `some()`: Returns `true` if at least one element passes the provided test.
*   `filter()`: Creates a new array with all elements that pass the provided test.
*   `indexOf()`: Returns the index of the first occurrence of the specified value in the array. If the value is not found, it returns -1.
*   `includes()`: Returns `true` if the array includes the element at the specified index.

**Pros and Cons:**

*   **some():**
    *   Pros:
        *   More concise and expressive than other methods
        *   Can be more efficient for large arrays since it stops as soon as it finds a match
    *   Cons:
        *   Returns `true` or `false`, which might not be what you want if the method is expected to return an index or value
*   **filter():**
    *   Pros:
        *   Creates a new array with all matching elements, which can be useful in some cases
        *   Can be more efficient than other methods for small arrays since it only iterates over the elements that match the test
    *   Cons:
        *   Returns an array, not just the index or value of the first match
*   **indexOf():**
    *   Pros:
        *   Returns the exact index of the first occurrence of the specified value
    *   Cons:
        *   Can be slower than other methods since it has to scan the entire array to find a match
*   **includes():**
    *   Pros:
        *   Fast and efficient for most cases
        *   Returns `true` or `false`, which might be what you want in some cases
    *   Cons:
        *   Less expressive than other methods, since it doesn't return an index or value

**Library/Functionality Descriptions:**

*   None explicitly mentioned in the benchmark definition.

**Special JavaScript Feature/Syntax (if applicable):**
None explicitly mentioned.

**Other Considerations:**

*   When choosing a method for searching within an array, consider the specific requirements of your use case. If you need to find the index or value of the first match, `indexOf()` might be the best choice. However, if you want to stop as soon as you find a match and return `true` or `false`, `some()` could be a better option.
*   For small arrays, `filter()` can be more efficient since it only iterates over the elements that match the test.
*   The `includes()` method is generally fast and efficient but might not be as expressive as other methods.

**Alternatives:**

*   Other array methods that could be used for this purpose include:
    *   `forEach()`: Iterates over each element in the array, which can be useful if you need to perform some operation on each match.
    *   `map()`: Creates a new array with the results of applying the provided function on each element in the original array. This might not be what you want if you're just looking for a specific value within the array.
*   For more complex search operations, other libraries or frameworks like Lodash might provide more convenient and expressive functions for searching within arrays.

In conclusion, when choosing a method for searching within an array in JavaScript, consider your specific requirements and choose the most suitable option based on factors such as performance, expressiveness, and readability.

Some vs. Filter vs. indexOf vs. Includes vs. Find in Object (version: 0)

Searching for value in object in array.

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

Created: 4 years ago by: Guest

Go to the latest result

Array.some

Array.filter

Array.indexOf

Array.includes

Array.find

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Some vs. Filter vs. indexOf vs. Includes vs. Find in Object (version: 0)

Searching for value in object in array.

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

Created: 4 years ago by: Guest

Go to the latest result

Array.some

Array.filter

Array.indexOf

Array.includes

Array.find

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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