Benchmark: findIndex primitive vs findIndex object

Script Preparation code:

var arrN = new Array(15000);

for (var i = 0; i < 15000; i++) {
	arrN[i] = { id: i };
}

var randN = Math.floor(Math.random() * 15000);

var arrP = new Array(15000);

for (var i = 0; i < 15000; i++) {
	arrP[i] = i;
}

var randP = Math.floor(Math.random() * 15000);

Tests:

findIndex non-primitive
var indexN = arrN.findIndex((num) => num['id'] === randN);
findIndex primitive
var indexP = arrP.findIndex((num) => num === randP);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
findIndex non-primitive
findIndex primitive

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 89 on Windows

View result in a separate tab

Test name	Executions per second
findIndex non-primitive	2634.8 Ops/sec
findIndex primitive	1172.2 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 2 months 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 website "MeasureThat.net" provides a platform for creating and running JavaScript microbenchmarks. The current benchmark is designed to compare the performance of two approaches within the `findIndex` method: one that compares primitive values (numbers) and another that compares non-primitive values (objects).

**Test Cases**

There are two individual test cases:

1. **"findIndex non-primitive"`**: This test case uses the `findIndex` method to search for an object in the `arrN` array, where each element is an object with an `id` property. The comparison is done using the condition `num['id'] === randN`, where `randN` is a random index between 0 and 14999.
2. **"findIndex primitive"`**: This test case uses the `findIndex` method to search for a number in the `arrP` array, where each element is a simple number. The comparison is done using the condition `num === randP`, where `randP` is a random index between 0 and 14999.

**Library Usage**

In both test cases, the `findIndex` method is used from the built-in JavaScript Array prototype. No additional libraries are required for these tests.

**Special JS Features or Syntax**

There are no special JavaScript features or syntax used in these test cases beyond what's inherent to the language itself (e.g., array literals, object properties).

**Pros and Cons of Different Approaches**

The two approaches being compared have different performance characteristics:

* **"findIndex non-primitive"`**: When searching for an object with a specific property value, `findIndex` needs to iterate through the entire array to check each element's property. This can be slower than the alternative approach.
	+ Pros: Easy to implement and understand.
	+ Cons: May be slower due to unnecessary iterations.
* **"findIndex primitive"`**: When searching for a simple number, `findIndex` only needs to iterate through the array until it finds the matching value. This is generally faster than the first approach.
	+ Pros: Can be faster due to reduced iterations.
	+ Cons: Requires a specific data structure (a plain array of numbers) and can be less flexible.

**Other Considerations**

* **Cache performance**: The `findIndex` method uses caching to store previously computed results. This can impact performance if the benchmark is run multiple times with different input values.
* **Type coercion**: When comparing objects using the `===` operator, JavaScript performs type coercion, which may lead to additional overhead.

**Alternative Approaches**

If you want to explore alternative approaches for finding an element in a large array:

1. **Linear search**: Iterate through the entire array until the matching value is found.
2. **Binary search**: Sort the array and use a binary search algorithm to find the matching value.
3. **Hash table-based search**: Use a hash table (e.g., `Map` or `Set`) to store the elements and quickly look up the matching value.

Keep in mind that these alternative approaches may have different performance characteristics, pros, and cons compared to the built-in `findIndex` method.

Related benchmarks:

findIndex primitive vs findIndex object (version: 0)

Difference within findIndex itself in performance between comparing primitive and non-primitive values.

Comparing performance of: findIndex non-primitive vs findIndex primitive

Created: 3 years ago by: Registered User

Jump to the latest result

findIndex non-primitive

findIndex primitive

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