Benchmark: indexOf vs $.inArray

HTML Preparation code:

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>

Script Preparation code:

var array_list = [];
for (var i = 0; i < 1000; i++) {
	array_list[i] = i;
}

Tests:

indexOf first
array_list.indexOf(0);
$.inArray first
jQuery.inArray(0, array_list);
indexOf last
array_list.indexOf(999);
$.inArray last
jQuery.inArray(999, array_list);
indexOf middle
array_list.indexOf(499);
$.inArray middle
jQuery.inArray(499, array_list);
indexOf
array_list.indexOf(0); array_list.indexOf(499); array_list.indexOf(999);
$.inArray
jQuery.inArray(0, array_list); jQuery.inArray(499, array_list); jQuery.inArray(999, array_list);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
indexOf first
$.inArray first
indexOf last
$.inArray last
indexOf middle
$.inArray middle
indexOf
$.inArray

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 26 days ago)

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
indexOf first	59556632.0 Ops/sec
$.inArray first	32556542.0 Ops/sec
indexOf last	5532512.0 Ops/sec
$.inArray last	5146355.0 Ops/sec
indexOf middle	9701486.0 Ops/sec
$.inArray middle	8415840.0 Ops/sec
indexOf	3515436.2 Ops/sec
$.inArray	3107467.0 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 explanation of the provided benchmark.

**Overview**

The provided JSON represents a JavaScript microbenchmark that compares the performance of `indexOf` (a native JavaScript method) and `$inArray` (a jQuery utility function). The benchmark consists of 8 test cases, each measuring the execution time of the two methods for different input values: the first element in the array (`0`), the last element in the array (`999`), a middle value (`499`), and a combination of three consecutive elements.

**What is tested?**

The benchmark tests the performance of `indexOf` and `$inArray` on an array of integers. Specifically, it measures:

* The execution time of `indexOf` for different input values.
* The execution time of `$inArray` for different input values.
* The execution time of combining multiple consecutive calls to both methods.

**Options compared**

The benchmark compares two options:

1. **Native JavaScript's `indexOf`**: a built-in method that searches for an element in the array using binary search.
2. **jQuery's `$inArray`**: a utility function that searches for an element in the array.

**Pros and Cons of each approach:**

* **Native JavaScript's `indexOf`:**
	+ Pros:
		- Fast execution time due to its optimized implementation.
		- No dependencies on external libraries.
	- Cons:
		- Only available in modern browsers (ECMAScript 2015+).
		- May not work as expected in older browsers or environments.
* **jQuery's `$inArray`:**
	+ Pros:
		- Wide browser support, including older versions of Internet Explorer and Safari.
		- Easier to use and understand for developers familiar with jQuery.
	- Cons:
		- Slower execution time compared to native `indexOf`.
		- Adds an external library dependency.

**Library used**

The benchmark uses jQuery version 1.12.4, which was a popular version at the time of its release in 2015. `$inArray` is a utility function provided by jQuery that simplifies the process of finding an element in an array.

**Special JS feature or syntax**

None of the test cases use any special JavaScript features or syntax beyond what's required for the benchmark itself (e.g., `let`, `const`, arrow functions, etc.).

**Other alternatives**

If you're looking for alternative methods to implement `$inArray`-like behavior in your code, consider:

* Using a vanilla JavaScript implementation of `indexOf`, as shown above.
* Utilizing a library like Lodash, which provides a more comprehensive set of array utilities, including `findIndex`.
* Implementing a custom binary search algorithm using only native JavaScript functions (e.g., `for` loops).

The benchmark's results provide insights into the relative performance of `indexOf` and `$inArray`, which can inform your decision when choosing between these methods in different contexts.

Related benchmarks:

indexOf vs $.inArray (version: 5)

Comparing performance of: indexOf first vs $.inArray first vs indexOf last vs $.inArray last vs indexOf middle vs $.inArray middle vs indexOf vs $.inArray

Created: 7 years ago by: Registered User

Jump to the latest result

indexOf first

$.inArray first

indexOf last

$.inArray last

indexOf middle

$.inArray middle

indexOf

$.inArray

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