Benchmark: Includes vs. IndexOf vs. Filter vs. Find vs. FindIndex vs. Some vs. Map

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:

Includes
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.includes(v => v === 0);
IndexOf
var tempResult = !!Math.round(Math.random()) ? hasZero.indexOf(0) > -1 : withoutZero.indexOf(0) > -1;
Filter
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.filter(v => v === 0);
Find
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.find(v => v === 0);
FindIndex
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.findIndex(v => v === 0);
Some
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.some(v => v === 0);
Map
var tempResult = !!Math.round(Math.random()) ? hasZero.some(v => v === 0) : withoutZero.map(v => v === 0);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Includes
IndexOf
Filter
Find
FindIndex
Some
Map

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 110 on Windows

View result in a separate tab

Test name	Executions per second
Includes	1788749.4 Ops/sec
IndexOf	812866.2 Ops/sec
Filter	208762.1 Ops/sec
Find	502038.0 Ops/sec
FindIndex	494932.7 Ops/sec
Some	484184.1 Ops/sec
Map	102891.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided benchmark compares the performance of six different methods for finding elements in an array: `includes`, `indexOf`, `filter`, `find`, `findIndex`, and `some`. The test creates two arrays, `hasZero` and `withoutZero`, each with 10,000 random integers. The test then uses a randomly generated value to search for a specific element (in this case, 0) in both arrays using each of the six methods.

**Methods Compared**

1. **Includes**: Checks if an element is present in an array using the `includes` method.
2. **IndexOf**: Returns the index of the first occurrence of an element in an array using the `indexOf` method.
3. **Filter**: Creates a new array with all elements that pass a test (in this case, being equal to 0) using the `filter` method.
4. **Find**: Returns the value of the first element that passes a test (in this case, being equal to 0) using the `find` method.
5. **FindIndex**: Returns the index of the first occurrence of an element in an array that passes a test (in this case, being equal to 0) using the `findIndex` method.
6. **Some**: Checks if at least one element in an array passes a test (in this case, being equal to 0) using the `some` method.
7. **Map**: Creates a new array with the results of applying a function to each element in an array using the `map` method.

**Pros and Cons**

* **Includes**: Simple and efficient for small arrays, but can be slow for large arrays due to its linear search algorithm. Pros: easy to use, cons: slow performance.
* **IndexOf**: Returns the index of an element, which can be useful in certain scenarios. Pros: fast performance, cons: only returns the index, not the value.
* **Filter**: Creates a new array with filtered elements, which can be memory-intensive for large arrays. Pros: allows for filtering and mapping, cons: creates a new array, uses more memory.
* **Find**: Returns the first matching element, which can be useful in certain scenarios. Pros: fast performance, cons: only returns one value, not the entire array.
* **FindIndex**: Similar to `indexOf`, but returns the index of the first occurrence. Pros: fast performance, cons: only returns an index, not the value.
* **Some**: Checks if at least one element passes a test, which can be useful for early exit conditions. Pros: fast performance, cons: may not be as efficient as other methods.
* **Map**: Creates a new array with transformed elements, which can be memory-intensive for large arrays. Pros: allows for transformation and filtering, cons: creates a new array, uses more memory.

**Library Used**

No libraries are explicitly mentioned in the benchmark definition or test cases. However, it's likely that some JavaScript functions (e.g., `Math.random()`, `Array.prototype.includes()`, etc.) are using built-in JavaScript libraries or implementations under the hood.

**Special JS Features/Syntax**

None of the test cases use any special JavaScript features or syntax beyond basic array operations and functions like `Math.random()`.

In conclusion, this benchmark provides a useful comparison of six different methods for finding elements in an array, highlighting their performance characteristics, pros, and cons. It can serve as a reference point for developers to choose the most efficient method for their specific use case.

Related benchmarks:

Includes vs. IndexOf vs. Filter vs. Find vs. FindIndex vs. Some vs. Map (version: 0)

Comparing performance of: Includes vs IndexOf vs Filter vs Find vs FindIndex vs Some vs Map

Created: one year ago by: Guest

Jump to the latest result

Includes

IndexOf

Filter

Find

FindIndex

Some

Map

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