Benchmark: Map vs Object - More items6

Script Preparation code:

var map = new Map();
var obj = {};
for (let i = 0; i < 50; i++) {
  map.set('a' + i, i);
  obj['a' + i] = i;
}
obj = Object.freeze(obj)

var i = 0, count = 1000, a;

Tests:

Map lookup
for (i = 0; i < count; i++) { a = map.get('a' + i); }
Obj lookup
for (i = 0; i < count; i++) { a = obj['a' + i]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map lookup
Obj lookup

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 126 on Windows

View result in a separate tab

Test name	Executions per second
Map lookup	4246.0 Ops/sec
Obj lookup	3722.7 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**What is being tested?**

The benchmark measures the performance difference between using a `Map` data structure and an object (`obj`) for key-value storage in JavaScript. Both approaches are used to store 50 items with unique keys, and then, using two separate loops, retrieve these values by their corresponding keys.

**Options compared:**

There are two options being compared:

1. **Map lookup**: Using the `get()` method to retrieve a value from the map.
2. **Object lookup**: Directly accessing an object property using bracket notation (`obj['a' + i]`).

**Pros and Cons of each approach:**

*   **Map lookup (for())**:
    *   Pros:
        *   Map operations are generally faster than object operations due to the optimized hash table implementation.
        *   Map provides additional methods like `has()`, `keys()`, `values()`, etc., making it a more flexible data structure.
    *   Cons:
        *   Maps have a higher memory overhead compared to objects, especially for large datasets.
*   **Object lookup (for())**:
    *   Pros:
        *   Objects are inherently lightweight and don't incur the additional overhead of hash table management.
        *   Object methods like `hasOwnProperty()` can be used for property existence checks.
    *   Cons:
        *   Object lookups can be slower due to the linear search algorithm used in JavaScript.

**Library usage:**

The benchmark doesn't explicitly mention any external libraries. However, it uses built-in JavaScript features and data structures (`Map` and `Object`). The presence of `Object.freeze()` suggests that the object is being made immutable for the purpose of this benchmark.

**Special JS feature or syntax:**

There are two special features used in this benchmark:

1.  **Template literals**: Used to create string constants in the `Script Preparation Code`. Template literals provide a more readable and concise way to construct strings.
2.  **Arrow functions**: Not explicitly mentioned but implied, as they are used in the loop bodies (`a = map.get('a' + i);` and `a = obj['a' + i];`). Arrow functions offer a more concise syntax for function expressions.

**Alternatives:**

Some alternative approaches or data structures that could be used in this benchmark:

1.  **Array**: Instead of using `Map` or objects, an array with the keys as indices could be used.
2.  **Set**: A `Set` data structure is a collection of unique values and provides efficient membership testing.
3.  **Proxy**: A proxy object can be used to implement custom access control and behavior for existing objects.

These alternatives might not exactly replicate the same scenario, but they would demonstrate different aspects of JavaScript's capabilities and trade-offs between various data structures and approaches.

Related benchmarks:

Map vs Object - More items6 (version: 0)

Lookup of map vs object

Comparing performance of: Map lookup vs Obj lookup

Created: one year ago by: Guest

Jump to the latest result

Map lookup

Obj lookup

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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