Benchmark: IndexOfArray - MeasureThat.net

Script Preparation code:

var array = ["hello", "tobeFound", "my"];

Tests:

test
!array.includes("tobeFound")
test 2
array.indexOf("tobeFound") !== -1

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
test
test 2

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 3 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 11_5_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.182 Safari/537.36

Browser/OS: Chrome 88 on Mac OS X 11.5.1

View result in a separate tab

Test name	Executions per second
test	26406162.0 Ops/sec
test 2	23493102.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to explain what's being tested in the provided benchmark.

**Benchmark Definition**

The benchmark definition is a JSON object that describes the test case. In this case, there are two benchmark definitions:

1. `"Name": "IndexOfArray", "Description": "Index of"`, which defines a general test case for indexing an array.
2. The second one is not explicitly defined in the given data, so we will skip it and move to individual test cases.

**Script Preparation Code**

The script preparation code is a JavaScript snippet that sets up the test environment:

`var array = ["hello", "tobeFound", "my"];`

This code defines an array variable named `array` with three string elements. This array will be used for indexing tests.

**Individual Test Cases**

There are two individual test cases:

1. `"Benchmark Definition": "!array.includes(\"tobeFound\")"`, which is a benchmark that checks if the element "tobeFound" is not in the array using the `includes()` method.
	* **What's being tested**: The performance of the `includes()` method when searching for an element that doesn't exist in the array.
2. `"Benchmark Definition": "array.indexOf(\"tobeFound\") !== -1"` , which is a benchmark that checks if the index of "tobeFound" in the array is not -1, i.e., it exists.
	* **What's being tested**: The performance of the `indexOf()` method when searching for an element that exists in the array.

**Library and Purpose**

Neither of the individual test cases uses a specific library. However, they do rely on built-in JavaScript methods:

* `includes()`: A method introduced in ECMAScript 2019 (ES10) that checks if an element is present in an array.
* `indexOf()`: A method that returns the index of the first occurrence of a specified value within an array.

**Special JS Feature or Syntax**

Neither of the individual test cases uses any special JavaScript features or syntax.

**Options Compared**

The two benchmark definitions are:

1. Using the `includes()` method to search for an element.
2. Using the `indexOf()` method to search for an element.

These two approaches have different performance characteristics:

* `includes()`: Faster and more efficient, especially when searching for elements that don't exist in the array.
* `indexOf()`: Slower and less efficient, as it searches the entire array until it finds the matching element or reaches the end.

**Pros and Cons**

Pros of using `includes()`:

* Faster performance
* More efficient
* Less CPU usage

Cons of using `includes()`:

* May not be supported in older browsers
* May have different behavior when searching for elements that don't exist

Pros of using `indexOf()`:

* Widely supported in older browsers
* Can provide more information about the index of the matching element

Cons of using `indexOf()`:

* Slower performance
* More CPU usage
* May not be suitable for large arrays or high-performance applications

**Other Alternatives**

If you need to search for an element in an array and want to consider alternative approaches, here are a few options:

1. **Array.prototype.forEach()**: You can use the `forEach()` method to iterate over the array elements and check if the current element matches the target value.
2. **Array.prototype.findIndex()**: This method returns the index of the first occurrence of the specified value in the array. If no match is found, it returns -1.
3. **Manual iteration**: You can use a manual loop to iterate over the array elements and check if the current element matches the target value.

However, these alternatives may not be as efficient or widely supported as using the built-in `includes()` and `indexOf()` methods.

Related benchmarks:

IndexOfArray (version: 0)

Index of

Comparing performance of: test vs test 2

Created: 3 years ago by: Guest

Jump to the latest result

test

test 2

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