Benchmark: Find in two arrays

Script Preparation code:

var aaa = [1,2,3];
var bbb = [2,3,4];
var term = 1;

Tests:

separate
aaa.indexOf(term) > -1 || bbb.indexOf(term) > -1
concat
aaa.concat(bbb).indexOf(term) > -1
cool concat
[...aaa, ...bbb].indexOf(term) > -1

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
separate
concat
cool concat

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4214.2 Safari/537.36

Browser/OS: Chrome 86 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
separate	5383342.0 Ops/sec
concat	2286966.0 Ops/sec
cool concat	3065452.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The provided benchmark tests three different approaches to find an element in two arrays: `indexOf`, `concat`, and a more modern approach using the spread operator (`...`). The benchmark aims to determine which method is the most efficient.

**Script Preparation Code**

The script preparation code initializes two arrays, `aaa` and `bbb`, with some sample values. It also sets up a variable `term` to be searched for in both arrays.

```javascript
var aaa = [1,2,3];
var bbb = [2,3,4];
var term = 1;
```

**Html Preparation Code**

There is no HTML preparation code provided, which means that the benchmark focuses solely on the JavaScript implementation.

**Test Cases**

The test cases are defined in the following JSON array:

```json
[
    {
        "Benchmark Definition": "aaa.indexOf(term) > -1 || bbb.indexOf(term) > -1",
        "Test Name": "separate"
    },
    {
        "Benchmark Definition": "aaa.concat(bbb).indexOf(term) > -1",
        "Test Name": "concat"
    },
    {
        "Benchmark Definition": "[...aaa, ...bbb].indexOf(term) > -1",
        "Test Name": "cool concat"
    }
]
```

Each test case defines a different benchmarking scenario:

* `separate`: Directly calls `indexOf` on both arrays individually and checks if the term exists in either of them.
* `concat`: Concatenates the two arrays using the spread operator (`...`) and then calls `indexOf` on the resulting array to find the term.
* `cool concat`: Similar to `concat`, but uses the spread operator (`...`) to concatenate the arrays. This approach is more modern and efficient.

**Library Used**

None of the test cases use any external libraries, which means that the results are specific to vanilla JavaScript implementation.

**Special JS Feature or Syntax**

The benchmark does not specifically target any special JavaScript features or syntax. However, it does demonstrate a modern approach using the spread operator (`...`), which is a standard feature in modern JavaScript implementations.

**Pros and Cons of Each Approach**

Here's a brief analysis of each approach:

* `separate`: This method is straightforward but may lead to slower performance due to the need to search for the term in both arrays individually.
* `concat`: Concatenating the arrays using the spread operator can be efficient, as it allows the browser to optimize the array creation process. However, this approach may incur additional overhead due to the temporary array creation.
* `cool concat`: This modern approach using the spread operator is likely to be the most efficient, as it avoids creating a temporary array and directly searches for the term in the concatenated array.

**Other Alternatives**

Some alternative approaches that could have been tested include:

* Using `find` instead of `indexOf`, which may provide better performance due to early termination.
* Using a more advanced data structure like a Set or a Trie, which may provide faster lookup times.
* Using SIMD instructions (if supported by the browser) to perform multiple comparisons simultaneously.

However, these alternatives are not explored in the provided benchmark.

Related benchmarks:

Find in two arrays (version: 0)

Comparing performance of: separate vs concat vs cool concat

Created: 4 years ago by: Guest

Jump to the latest result

separate

concat

cool concat

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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