Benchmark: Yet another bad Map vs Object read benchmark

Script Preparation code:

var n = 730;
var entries = [...Array(n)].map((_, i) => ['k' + i, i]) ;
var m = new Map(entries);
var o = Object.fromEntries(entries);

Tests:

object read
let ro = ""; for (let i = 0, len = entries.length; i < entries.length; ++i) { ro += o[entries[i][0]]; }
map read
let rm = ""; for (let i = 0, len = entries.length; i < entries.length; ++i) { rm += m.get(entries[i][0]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
object read
map read

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 94 on Windows

View result in a separate tab

Test name	Executions per second
object read	3406.1 Ops/sec
map read	4525.5 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll do my best to explain the benchmark and its various aspects.

**What is being tested?**

The provided benchmark tests two ways of reading data from an object (or a Map) in JavaScript: using Object.fromEntries() and using Map.prototype.get(). The test measures the performance difference between these two approaches, specifically how fast each method can concatenate the values associated with the keys.

**Options compared**

There are only two options being compared:

1. **Object.read**: This approach uses `Object.fromEntries()` to create an object from a given array of key-value pairs, and then iterates over the object's entries using a for loop to concatenate the values.
2. **Map.read**: This approach creates a new Map from the same array of key-value pairs and uses the Map.prototype.get() method to retrieve each value associated with its corresponding key.

**Pros and Cons**

*   **Object.read**:
    *   Pros: It's a more intuitive way to read data from an object, as it uses a familiar JavaScript method. However, this approach is slower than Map.read due to the overhead of creating and manipulating an object.
    *   Cons: It's less efficient because of the object creation process and string concatenation.
*   **Map.read**:
    *   Pros: It's faster and more memory-efficient since it doesn't create a new object, but instead uses a specialized data structure designed for key-value pairs. This approach is also more concise and easier to read.
    *   Cons: The Map.prototype.get() method may not be as familiar or intuitive to some developers.

**Library usage**

In the provided benchmark code, no external library is used other than JavaScript's built-in `Array`, `Map`, and `Object` methods. However, it's essential to note that using libraries or frameworks can significantly impact performance.

**Special JavaScript features/syntax**

None of the special JavaScript features or syntax are being tested in this benchmark. It only focuses on the differences between using objects and Maps for key-value pairs.

**Other alternatives**

If you're looking for alternative ways to read data from an object, some possible approaches include:

*   Using `for...in` loops with `Object.keys()` or `Object.getOwnPropertyNames()`.
*   Utilizing libraries like Lodash's `mapValues()` function.
*   Leveraging the `reduce()` method to concatenate values.

Keep in mind that each of these alternatives may have its own trade-offs in terms of performance, readability, and maintainability.

Related benchmarks:

Yet another bad Map vs Object read benchmark (version: 0)

Comparing performance of: object read vs map read

Created: 3 years ago by: Guest

Jump to the latest result

object read

map read

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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