Benchmark: Map vs JSON - MeasureThat.net

Script Preparation code:

var data = [
    {name: "anonystick", sex:1, age: 42, phone: 03543214564},
    {name: "medium", sex:0, age: 45, phone: 0321452145},
    {name: "subrss", sex:1, age: 41, phone: 03789456785}
]

Tests:

Map
const map = new Map(data.map(item=> [item.name, item])); data.map(( {name} )=> map[name] ?? null);
Json
const json = data.reduce((acc, item) => { acc[item.account] = item.rank return acc }, {}); data.map( ({name})=> json[name] ?? null)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map
Json

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/134.0.0.0 Safari/537.36

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
Map	11730592.0 Ops/sec
Json	15441858.0 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.

The benchmark being tested is the performance difference between using a `Map` data structure and a JSON object to store and retrieve key-value pairs in JavaScript. The test case consists of two individual tests: "Map" and "Json".

**What are we testing?**

We're testing the performance of two approaches:

1. Using a `Map` data structure to store and retrieve key-value pairs. A `Map` is a built-in JavaScript object that stores key-value pairs, where each key is unique and maps to a specific value.
2. Using a JSON object (a JavaScript representation of the JavaScript Object Notation format) to store and retrieve key-value pairs.

**Options compared**

The two options are being compared in terms of performance, specifically in terms of the number of executions per second.

**Pros and Cons:**

**Map:**

Pros:

* Efficient lookups: `Map` provides fast and efficient lookup operations, with an average time complexity of O(1).
* Compact storage: `Map` stores key-value pairs in a compact format, which can lead to better memory usage.

Cons:

* Less intuitive for developers familiar with JSON or hash tables.
* May require additional setup for complex data structures.

**JSON:**

Pros:

* More intuitive for developers familiar with JSON or hash tables.
* Can be easily converted from and to human-readable formats.

Cons:

* Slower lookup operations compared to `Map`, with an average time complexity of O(n).
* Less compact storage compared to `Map`.

**Library usage**

Neither test case uses any external libraries. However, it's worth noting that the `reduce()` method used in the "Json" benchmark is a built-in JavaScript function.

**Special JS features or syntax**

There are no special JavaScript features or syntax being tested in this benchmark.

**Other considerations**

* The test data consists of a simple array of objects, which may not represent real-world use cases.
* The benchmark does not account for factors like cache coherence or memory allocation, which can impact performance.
* Future benchmarks could explore additional optimization techniques, such as parallelization or caching.

**Alternatives**

If you're interested in exploring alternative approaches to this benchmark, here are a few options:

1. **Using `WeakMap`**: Similar to `Map`, but with the added benefit of using weak references for key-value pairs.
2. **Using `Array.prototype.reduce()` with a different data structure**: Experimenting with different data structures, such as an array or a Set, could reveal performance differences that are not accounted for in this benchmark.
3. **Adding more complex test cases**: Incorporating more realistic test cases, such as nested objects or arrays, could provide a better representation of real-world performance scenarios.

Keep in mind that the goal of microbenchmarks is to measure the performance of specific code snippets, so it's essential to carefully design and optimize these tests to accurately reflect the performance characteristics being measured.

Related benchmarks:

Map vs JSON (version: 0)

Map vs JSON

Comparing performance of: Map vs Json

Created: 2 years ago by: Guest

Jump to the latest result

Map

Json

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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