Benchmark: Array find vs Map get

Script Preparation code:

const list = [{
	id: "a",
  name: "asd",
  age: 12,
  isValid: false,
},
 {
	id: "b",
  name: "bsd",
  age: 12,
  isValid: false,
},
 {
	id: "c",
  name: "c",
  age: 12,
  isValid: false,
},
             {
	id: "d",
  name: "dsd",
  age: 12,
  isValid: false,
},
             {
	id: "e",
  name: "esd",
  age: 12,
  isValid: false,
},
                          {
	id: "f",
  name: "fsd",
  age: 12,
  isValid: false,
},
                          {
	id: "g",
  name: "gsd",
  age: 12,
  isValid: false,
},
                          {
	id: "h",
  name: "hsd",
  age: 12,
  isValid: false,
},
                          {
	id: "i",
  name: "isd",
  age: 12,
  isValid: false,
},];

var map = new Map();
list.forEach((obj) => {
  map.set(obj.id, obj);
});

var id = "e";

Tests:

Array
var foundObj = list.find((obj) => obj.id === id); foundObj.isValid = true;
Map
var foundObj2 = map.get(id); foundObj2.isValid = true;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Array
Map

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 what is being tested in the provided JSON benchmark.

**Benchmark Definition**

The benchmark compares two approaches to find an object in a list:

1. **Array**: Using the `find()` method, which iterates over the array and returns the first element that satisfies the condition.
2. **Map**: Using the `get()` method, which directly accesses the value associated with a given key (in this case, the `id` property).

**Options compared**

The options being compared are:

* Array's `find()` method vs Map's `get()` method
* The use of iteration (Array) vs direct access (Map)

**Pros and Cons of each approach**

**Array (`find()`)**

Pros:

* Easier to implement, as it only requires modifying the existing array.
* Allows for more flexibility in searching criteria.

Cons:

* Iteration can be slower than direct access, especially for large datasets.
* May return null if no matching element is found, requiring additional checks.

**Map (`get()`)**

Pros:

* Direct access to data, which can be faster than iteration.
* Returns a specific value directly, eliminating the need for further processing.

Cons:

* Requires creating an index (the Map) before performing lookups.
* May not be as flexible as array-based searches.

**Library and purpose**

In this benchmark, two libraries are used:

1. **Array**: Built-in JavaScript array methods.
2. **Map**: Built-in JavaScript Map object.

Both libraries are essential for working with data structures in JavaScript.

**Special JS features or syntax**

This benchmark does not use any special JavaScript features or syntax beyond the standard `find()`, `get()`, and `set()` methods.

**Other alternatives**

If you wanted to explore alternative approaches, here are a few options:

* Using a custom data structure (e.g., a balanced binary search tree) for faster lookup times.
* Implementing a hybrid approach that combines array-based searching with direct access using a Map or other data structure.
* Utilizing WebAssembly (WASM) or other just-in-time compilation technologies to optimize performance.

Keep in mind that these alternatives would likely require significant changes to the benchmark code and may not offer substantial benefits over the standard Array and Map approaches.

Related benchmarks:

Array find vs Map get (version: 0)

Comparing performance of: Array vs Map

Created: 4 years ago by: Guest

Jump to the latest result

Array

Map

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