Benchmark: 1000 test - MeasureThat.net

Script Preparation code:

var items = [];
var i;
for (i = 0; i < 1000; i++) {
    items.push('100' + i)
}

Tests:

Find
items.find(id => id == "100995")
indexOf
items.indexOf("100995")
includes
items.includes("100995")

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Find
indexOf
includes

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Linux; Android 10; SM-G9650) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Mobile Safari/537.36

Browser/OS: Chrome Mobile 87 on Android

View result in a separate tab

Test name	Executions per second
Find	70375.5 Ops/sec
indexOf	6523139.5 Ops/sec
includes	6629923.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 explaining the provided benchmark.

**Benchmark Overview**

The benchmark is designed to measure the speed of three different methods for finding an item in an array: `find`, `indexOf`, and `includes`. The test case consists of creating an array of 1000 items, each represented as a string "100" followed by a number from 0 to 999. The purpose of this benchmark is to compare the performance of these three methods in finding a specific item within the array.

**Options Compared**

The options compared are:

1. `find(id => id == "100995")`
2. `items.indexOf("100995")`
3. `items.includes("100995")`

These three methods are all used to find the index of the item "100995" in the array. The main difference between them lies in how they handle the absence of the target element:

* `find` returns `undefined` if the element is not found.
* `indexOf` returns `-1` if the element is not found.
* `includes` returns a boolean value (`true` or `false`) indicating whether the element is present in the array.

**Pros and Cons**

Here are some pros and cons of each method:

* `find`:
	+ Pros: More concise and expressive, as it uses an arrow function to define the search predicate.
	+ Cons: May be slower than `indexOf` or `includes` due to its overhead.
* `indexOf`:
	+ Pros: Faster than `find` because it only searches for a single element, rather than iterating over the array.
	+ Cons: Returns `-1` if the element is not found, which may not be as intuitive as returning `undefined`.
* `includes`:
	+ Pros: Returns a boolean value, making it more suitable for use in conditional statements.
	+ Cons: May be slower than `indexOf` due to its overhead.

**Library and Purpose**

In this benchmark, the array is created using a simple JavaScript loop. No external libraries are required or used.

**Special JS Feature or Syntax**

There is no special feature or syntax being tested in this benchmark. The focus is on comparing the performance of three different methods for finding an item in an array.

**Other Alternatives**

Some alternative methods that could be compared in a similar benchmark include:

* `binarySearch`: a more efficient algorithm for finding an element in a sorted array.
* `filter` and `every`/`some`: methods that can be used to search for elements in an array, but may have different performance characteristics.

Overall, this benchmark provides a good starting point for comparing the performance of different methods for finding an item in an array.

Related benchmarks:

1000 test (version: 0)

test the speed of finding in 1000 items

Comparing performance of: Find vs indexOf vs includes

Created: 3 years ago by: Guest

Jump to the latest result

Find

indexOf

includes

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