Benchmark: includes vs in vs indexOf

Script Preparation code:

var codes = [];
var usedCodes = [];
for(i=0; i<10000; i++){
	codes.push(i);
  	if (i % 2) usedCodes.push(i);
}

Tests:

indexOf
codes.forEach(x => { if (usedCodes.indexOf(x) > -1) { } });
in
codes.forEach(x => { if (x in usedCodes) { } });
includes
codes.forEach(x => { if (usedCodes.includes(x)) { } });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf
in
includes

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to explain the provided benchmark and its various components.

**Overview of the Benchmark**

The provided benchmark is designed to compare the performance of three different ways to check if an element exists in an array: `indexOf`, `in` (the old way, deprecated since ES6), and `includes`.

**Benchmark Definition JSON**

The benchmark definition JSON contains the following information:

*   **Name**: The name of the benchmark, which is "includes vs in vs indexOf".
*   **Description**: An empty string indicating no description for this benchmark.
*   **Script Preparation Code**: A script that generates two arrays, `codes` and `usedCodes`, containing 10,000 elements each. The `usedCodes` array has every second element from the `codes` array.
*   **Html Preparation Code**: An empty string, indicating no HTML preparation code is needed.

**Individual Test Cases**

The benchmark consists of three individual test cases:

*   **Test Case 1: "indexOf"`**: This test case uses the `indexOf` method to check if an element exists in the `usedCodes` array. The benchmark definition JSON contains this line of code:
    ```javascript
codes.forEach(x => {
  if (usedCodes.indexOf(x) > -1) {}
});
```
*   **Test Case 2: "in"`**: This test case uses the old way to check if an element exists in the `usedCodes` array, which is now deprecated. The benchmark definition JSON contains this line of code:
    ```javascript
codes.forEach(x => {
  if (x in usedCodes) {}
});
```
*   **Test Case 3: "includes"`**: This test case uses the `includes` method to check if an element exists in the `usedCodes` array. The benchmark definition JSON contains this line of code:
    ```javascript
codes.forEach(x => {
  if (usedCodes.includes(x)) {}
});
```

**Pros and Cons of Each Approach**

Here's a brief overview of each approach, including their pros and cons:

*   **indexOf**: This method searches for the first occurrence of the specified value in the array. If not found, it returns -1.
    *   Pros: Efficient, fast, and widely supported across browsers.
    *   Cons: Returns -1 instead of null if not found, which might be seen as incorrect behavior by some developers.
*   **in**: This method was used before ES6 to check for existence. It's now deprecated in favor of `includes`.
    *   Pros: None significant.
    *   Cons: Slow, inefficient, and not supported by all browsers.
*   **includes**: Introduced in ES6, this method is more efficient and readable than the old `in` approach.
    *   Pros: Efficient, fast, and widely supported across modern browsers. It also returns a boolean value (true/false) instead of null or -1.
    *   Cons: Not supported by older browsers.

**Library Used**

In this benchmark, no library is explicitly used. However, if you're interested in using libraries like Lodash, Ramda, or Array.prototype.filter(), they might provide more efficient and concise ways to check for existence.

**Special JS Feature or Syntax**

No special JavaScript feature or syntax is used in the provided benchmark code. The focus is solely on comparing three different approaches to check for element existence in an array.

**Alternatives**

If you're interested in exploring alternatives, here are a few options:

*   Use `Array.prototype.includes()`: This method is supported by modern browsers and provides a concise way to check if an element exists in the array.
*   Utilize libraries like Lodash or Ramda: These libraries provide more efficient and functional programming approaches to checking for existence.
*   Implement your own custom implementation using bitwise operations (e.g., using `Math.floor(Math.log2(x))` to determine the number of bits needed to represent `x`, then performing a bitwise AND operation with the powers of 2).
*   Explore alternative data structures, such as Sets or Maps, which can provide more efficient lookup times.

Keep in mind that these alternatives might not be suitable for all use cases and may add complexity to your codebase. Always consider the trade-offs and the specific requirements of your project when choosing an approach.

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/97.0.4692.71 Safari/537.36

Browser/OS: Chrome 97 on Windows

View result in a separate tab

Test name	Executions per second
indexOf	12.4 Ops/sec
in	1131.2 Ops/sec
includes	1141.4 Ops/sec

Related benchmarks:

includes vs in vs indexOf (version: 0)

Comparing performance of: indexOf vs in vs includes

Created: 2 years ago by: Guest

Jump to the latest result

indexOf

in

includes

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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