Benchmark: searching for element in array

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var mySmallArray = [1,2,3,4,5,6,7,8,9,10];
var myLargeArray = [];
for (var i = 0; i < 4096; i++) {
  myLargeArray.push(i); 
}

Tests:

[].includes small
mySmallArray.includes(5);
[].includes large beginning
myLargeArray.includes(5);
[].ncludes large end
myLargeArray.includes(4000);
_.includes large end
_.includes(myLargeArray, 4000);
indexOf smallArray
mySmallArray.indexOf(5) >= 0;
indexOf largeArray beginning
myLargeArray.indexOf(5) >= 0;
indexOf largeArray end
myLargeArray.indexOf(4000) >= 0;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
[].includes small
[].includes large beginning
[].ncludes large end
_.includes large end
indexOf smallArray
indexOf largeArray beginning
indexOf largeArray end

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Measuring the performance of JavaScript microbenchmarks is a complex task, and there are multiple ways to approach it. I'll break down the provided benchmark definition and individual test cases to explain what's being tested, the options compared, pros and cons of each approach, and other considerations.

**Benchmark Definition**

The benchmark definition provides a small array (`mySmallArray`) with 10 elements, used for testing the `includes` method. It also creates a large array (`myLargeArray`) with 4096 elements, used for testing different variations of the same method.

**Options Compared**

There are five test cases:

1. **`.includes()` on small array**: Tests the performance of the built-in `.includes()` method on the small array.
2. **`.includes()` on large array beginning**: Tests the performance of the built-in `.includes()` method on the large array, starting from the first element (index 0).
3. **`.includes()` on large array end**: Tests the performance of the built-in `.includes()` method on the large array, starting from the last element.
4. **`_.includes()` on large array**: Tests the performance of Lodash's `_.includes()` function on the large array.
5. **`.indexOf()` on small array**: Tests the performance of the built-in `.indexOf()` method on the small array.

**Pros and Cons**

1. **Built-in `.includes()` method**:
	* Pros: Fast, widely supported, and well-optimized by modern browsers.
	* Cons: May not be as efficient for very large arrays or when searching for elements at the beginning or end of the array.
2. **Lodash's `_.includes()` function**:
	* Pros: Flexible, can handle edge cases (e.g., finding all occurrences), and provides a consistent API.
	* Cons: May incur additional overhead due to its wrapper nature and possibly slower than the built-in method.
3. **`.indexOf()` method**:
	* Pros: Can be used for both searching for an exact element or determining the index of the first occurrence.
	* Cons: May not be as efficient as `.includes()` for large arrays, especially when searching from the beginning or end.

**Other Considerations**

* The benchmark measures the number of executions per second (ExecutionsPerSecond) using a UA string to identify the browser and device platform. This provides insight into performance variations across different browsers and devices.
* The use of Lodash's `_.includes()` function adds an additional layer of complexity, as it may not be optimized for every browser or environment.

**Alternatives**

If you were to create your own benchmarking framework, you might consider the following alternatives:

1. **Using a JavaScript profiling tool**, like Chrome DevTools or Node.js Inspector, to measure performance directly within the browser or Node.js environment.
2. **Implementing a custom benchmark loop** using Web Workers or a separate thread to isolate the testing environment and minimize interference with other processes.
3. **Utilizing a specialized library**, such asBenchmark.js or microbenchmark, which provides a more structured approach to measuring performance and can help mitigate variations in execution order.

By understanding these factors and alternatives, you'll be better equipped to design efficient benchmarks that provide accurate insights into the performance characteristics of your JavaScript code.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:62.0) Gecko/20100101 Firefox/62.0

Browser/OS: Firefox 62 on Windows 7

View result in a separate tab

Test name	Executions per second
[].includes small	32761438.0 Ops/sec
[].includes large beginning	29894298.0 Ops/sec
[].ncludes large end	100912.7 Ops/sec
_.includes large end	120657.9 Ops/sec
indexOf smallArray	38122668.0 Ops/sec
indexOf largeArray beginning	34865488.0 Ops/sec
indexOf largeArray end	123177.3 Ops/sec

Related benchmarks:

searching for element in array (version: 3)

Comparing performance of: [].includes small vs [].includes large beginning vs [].ncludes large end vs _.includes large end vs indexOf smallArray vs indexOf largeArray beginning vs indexOf largeArray end

Created: 6 years ago by: Registered User

Jump to the latest result

[].includes small

[].includes large beginning

[].ncludes large end

_.includes large end

indexOf smallArray

indexOf largeArray beginning

indexOf largeArray end

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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