Benchmark: Array Indexation vs. Array Access

Script Preparation code:

var testArray = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'nineteen', 'twenty'];

Tests:

array.includes at the beggining
testArray.includes('two'); testArray.includes('three'); testArray.includes('four'); testArray.includes('five');
array.includes at the end
testArray.includes('twenty'); testArray.includes('nineteen'); testArray.includes('eighteen'); testArray.includes('seventeen');
Indexation THEN check at the beggining
const testObject = {}; for (const key in testArray) testObject[key] = true; testObject['one']; testObject['two']; testObject['three']; testObject['four'];
Indexation THEN check at the end
const testObject = {}; for (const key in testArray) testObject[key] = true; testObject['twenty']; testObject['nineteen']; testObject['eighteen']; testObject['seventeen'];

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
array.includes at the beggining
array.includes at the end
Indexation THEN check at the beggining
Indexation THEN check at the end

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases to understand what is being tested.

**Benchmark Definition**

The main goal of this benchmark is to compare the performance of two approaches:

1. **Array Indexation vs. Array Access**: This involves checking whether it's faster to access an array by indexing (e.g., `testArray[0]`) versus using the `includes()` method (e.g., `testArray.includes('two')`).
2. The specific use case being tested is reading a subset of elements from the array, where the number of reads is small.

**Test Cases**

There are four test cases:

1. **array.includes at the beginning**: This test case checks the performance of `includes()` when it's called before accessing an element in the array.
2. **array.includes at the end**: Similar to the previous test case, but with a different order: `includes()` is called after accessing an element in the array.
3. **Indexation THEN check at the beginning**: In this test case, the indexation approach is used first, followed by a call to `includes()`.
4. **Indexation THEN check at the end**: Similar to the previous test case, but with a different order: indexing is done first, followed by a call to `includes()`.

**Libraries and Special Features**

* There is no explicit mention of any libraries being used in this benchmark.
* There are no special JavaScript features or syntaxes mentioned (e.g., async/await, Promises).

**Pros and Cons of Different Approaches**

1. **Array Indexation**: This approach has the advantage of being more direct and potentially faster, as it allows the browser to access the element directly without having to perform a search.
	* Disadvantage: If the array is large or if the element is not found, this approach can lead to performance issues.
2. **Array Access (includes())**: This approach is generally safer and more flexible, as it doesn't rely on the element being present in the array. However, it may be slower due to the search operation.
	* Advantage: Robustness against missing elements or edge cases.
	* Disadvantage: Potential performance overhead.

**Other Considerations**

* The benchmark is running on a desktop browser (Chrome 117) with a Windows operating system.
* There are many executions per second, indicating that this is a well-optimized test case.

**Alternatives**

If you wanted to modify or extend this benchmark, here are some possible alternatives:

1. **Use different browsers**: Test the performance of `includes()` and array indexing on other browsers (e.g., Firefox, Edge).
2. **Increase or decrease the number of reads**: Modify the size of the test case to see how it affects the performance difference between the two approaches.
3. **Introduce more complex scenarios**: Add additional factors, such as iterating over a subset of elements or using `includes()` with other methods (e.g., `indexOf()`, `findIndex()`).

By analyzing this benchmark definition and test cases, you can gain insights into the trade-offs between array indexing and array access methods, especially in situations where performance is critical.

Related benchmarks:

Array Indexation vs. Array Access (version: 0)

Checks whether it is faster to index an array before using it, or just using it as is, when few reads are involved

Comparing performance of: array.includes at the beggining vs array.includes at the end vs Indexation THEN check at the beggining vs Indexation THEN check at the end

Created: 2 years ago by: Guest

Jump to the latest result

array.includes at the beggining

array.includes at the end

Indexation THEN check at the beggining

Indexation THEN check at the end

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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