Benchmark: Array.includes() vs Array.indexOf() vs Array.some()

Script Preparation code:

var array = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];

Tests:

Array.includes()
var result = array.includes('d');
Array.indexOf()
var result = array.indexOf('d') > -1;
Array.some()
var result = array.some(v => v === 'd')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array.includes()
Array.indexOf()
Array.some()

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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.

**What is being tested?**

The provided JSON represents a benchmark that compares the performance of three different methods: `Array.includes()`, `Array.indexOf()`, and `Array.some()`.

**Options compared**

These three methods are used to check if a specific value exists in an array. Here's what each method does:

1. **`Array.includes()`**: Returns `true` if the specified value is found in the array, and `false` otherwise.
2. **`Array.indexOf()`**: Returns the index of the first occurrence of the specified value in the array. If the value is not found, it returns `-1`.
3. **`Array.some()`**: Returns `true` if at least one element in the array satisfies the provided condition. In this case, the condition is checking if any element is equal to `'d'`.

**Pros and cons of each approach**

Here are some pros and cons of each method:

*   `Array.includes()`: This method is generally the most efficient and straightforward way to check if an element exists in an array. However, it may not be suitable for large arrays or when searching for a specific index.
    *   Pros: Fast and easy to use.
    *   Cons: May not work well with very large arrays or when searching for a specific index.
*   `Array.indexOf()`:
    *   Pros: Returns the exact position of the element in the array, which can be useful in some cases. However, it may return `-1` if the value is not found, which can lead to incorrect results.
    *   Cons: May be slower than `includes()`, especially for large arrays. It also requires handling the case where the value is not found.
*   `Array.some()`:
    *   Pros: Can be used in conjunction with other conditions and returns a boolean value, making it more versatile than `includes()` or `indexOf()`. However, its performance can be slower than `includes()`.
    *   Cons: Returns `true` as soon as the condition is met, which may not be desirable if you're expecting to find all occurrences.

**Library and purpose**

In this benchmark, no library is explicitly mentioned. However, the methods themselves are part of the JavaScript standard library.

**Special JS feature or syntax**

None.

**Other alternatives**

If you need to check if a value exists in an array, other alternatives could be:

*   Using `Array.prototype.includes()` (which is essentially what's being compared)
*   Using a custom function with a loop
*   Using a third-party library like Lodash or Ramda

Keep in mind that the choice of method depends on the specific use case and performance requirements.

In this benchmark, MeasureThat.net provides a simple way to compare the performance of different methods. It allows users to easily create and run JavaScript microbenchmarks, making it easier to identify which method is most efficient for their specific needs.

Related benchmarks:

Array.includes() vs Array.indexOf() vs Array.some() (version: 0)

Comparing performance of: Array.includes() vs Array.indexOf() vs Array.some()

Created: 6 years ago by: Registered User

Jump to the latest result

Array.includes()

Array.indexOf()

Array.some()

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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