Benchmark: Map lookup 2 - MeasureThat.net

Script Preparation code:

let someMap = {}
for (let i = 0; i < 100; i++) {
    someMap[`${i}-test`] = i * 2
}

let someMapNumber = {}
for (let i = 0; i < 100; i++) {
    someMap[i] = i * 2
}

Tests:

string
let someMap = {} for (let i = 0; i < 100; i++) { someMap[`${i}-test`] = i * 2 } for (let i = 0; i < 100; i++) { console.log(someMap[`${i}-test`]) }
number
let someMapNumber = {} for (let i = 0; i < 100; i++) { someMapNumber[i] = i * 2 } for (let i = 0; i < 100; i++) { console.log(someMapNumber[i]) }
array
let array = [] for (let i = 0; i < 100; i++) { array.push(i * 2) } for (let i = 0; i < 100; i++) { console.log(array[i]) }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
string
number
array

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 benchmark and its various components.

**Benchmark Definition**

The benchmark definition is a JSON object that contains the code for a specific test case. In this case, there are three test cases: "map lookup 2", "string", and "array". The code for each test case consists of:

* A script preparation code that creates an object (either `someMap` or `someMapNumber`) with 100 entries, where the key is a string in the format "i-test" (or simply "i" for arrays) and the value is twice the index.
* An HTML preparation code that is empty for all test cases.

**Options Compared**

The benchmark compares three different approaches:

1. **Map lookup**: This approach uses a Map object to store and retrieve values. The map is created with 100 entries, where each entry has a string key (in the format "i-test" or simply "i") and a value that is twice the index.
2. **Array indexing**: This approach uses an array to store and retrieve values. The array is created with 100 elements, where each element's value is twice the index.
3. **String iteration**: This approach iterates over a string (in the format "i-test" or simply "i") using a for loop, logging each character to the console.

**Pros and Cons**

Here are some pros and cons of each approach:

* **Map lookup**:
	+ Pros: Fast lookups, good cache locality.
	+ Cons: May require more memory than other approaches.
* **Array indexing**:
	+ Pros: Simple to implement, good cache locality.
	+ Cons: May not be as fast as map lookups for large datasets.
* **String iteration**:
	+ Pros: Simple to implement, doesn't require extra data structures.
	+ Cons: May be slower than other approaches due to the overhead of string iteration.

**Library Usage**

There is no explicit library usage in this benchmark. However, it's worth noting that `Map` objects are a built-in JavaScript object that provides fast lookups and good cache locality.

**Special JS Features or Syntax**

The benchmark uses some special JavaScript features:

* **Template literals**: The code uses template literals to create strings with variables (e.g., `${i}-test`). This feature is supported in modern browsers.
* **For...of loops**: The code uses for-of loops to iterate over the array or map. This feature is supported in modern browsers.

**Other Alternatives**

If you want to compare different approaches, you could consider adding more test cases, such as:

* Using a different data structure (e.g., `Set` instead of `Map`)
* Implementing the array or string iteration approach using a different algorithm
* Adding additional overhead (e.g., using async/await or callbacks)
* Comparing performance on different devices or browsers

Keep in mind that the benchmark is designed to compare specific approaches, so adding new test cases may compromise the accuracy of the results.

Related benchmarks:

Map lookup 2 (version: 0)

Comparing performance of: string vs number vs array

Created: 5 years ago by: Guest

Jump to the latest result

string

number

array

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