Benchmark: Inserting and Searching in Map vs Object

Script Preparation code:

var small_pojo = {};
var small_map = new Map();
var small_vals = [];

var large_pojo = {};
var large_map = new Map();
var large_vals = [];

for(let i = 0; i < 1000; i++) {
  let val = btoa(Math.random()); // randomish string
  
  small_vals.push(val);
}

for(let i = 0; i < 100000; i++) {
  let val = btoa(Math.random()); // randomish string
  
  large_vals.push(val);
}

Tests:

Insert in small Map
small_vals.forEach(v => { small_map.set(v, v); });
insert in small POJO
small_vals.forEach(v => { small_pojo[v] = v; });
Insert in large Map
large_vals.forEach(v => { large_map.set(v, v); });
Insert in large POJO
large_vals.forEach(v => { large_pojo[v] = v; });
Search in small Map
small_vals.forEach(v => { return small_map.get(v); })
Search in small POJO
small_vals.forEach(v => { return small_pojo[v]; })
Search in large Map
large_vals.forEach(v => { return large_map.get(v); })
Search in large POJO
large_vals.forEach(v => { return large_pojo[v]; })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Insert in small Map
insert in small POJO
Insert in large Map
Insert in large POJO
Search in small Map
Search in small POJO
Search in large Map
Search in large POJO

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Insert in small Map	73795.7 Ops/sec
insert in small POJO	130688.7 Ops/sec
Insert in large Map	213.6 Ops/sec
Insert in large POJO	891.6 Ops/sec
Search in small Map	2926360.8 Ops/sec
Search in small POJO	159293.7 Ops/sec
Search in large Map	347.8 Ops/sec
Search in large POJO	1014.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring performance of JavaScript data structures is essential to understand how they scale and perform under various workloads.

**What's being tested?**

The benchmark tests the insertion and search operations on two different data structures: Maps (implemented using objects in JavaScript) and Plain Old JavaScript Objects (POJOs).

**Options compared:**

Two options are compared:

1. **Maps**: A built-in JavaScript data structure that provides fast lookup, insertion, and deletion of key-value pairs.
2. **POJOs**: Ordinary JavaScript objects without any special features or optimizations for performance.

**Pros and Cons:**

* **Maps**:
	+ Pros: Fast lookup (average time complexity O(1)), efficient insertion and deletion, and good memory usage compared to POJOs.
	+ Cons: May have higher overhead due to the creation of a `Map` object, which can be slower than using an object for simple data storage.
* **POJOs**:
	+ Pros: Simple and lightweight, easy to use, and no additional dependencies required.
	+ Cons: Slow lookup (average time complexity O(n)), slower insertion and deletion, and higher memory usage compared to Maps.

**Other considerations:**

When working with large datasets, the choice between using a Map or POJO depends on the specific requirements of your application. If you need fast lookups and efficient insertion/deletion operations, using a Map is likely a better choice. However, if simplicity and low overhead are more important, using POJOs might be sufficient.

**Library usage:**

None of the benchmark test cases use any libraries specifically for data structure operations. The `Map` class is built-in to JavaScript, while POJOs rely on standard JavaScript object methods (e.g., `set()`, `get()`).

**Special JS feature or syntax:**

The `btoa()` function is used to generate random base64-encoded strings for testing purposes. This function is not a specific JavaScript feature but rather a polyfill for older browsers.

In summary, the benchmark compares the performance of two data structures (Maps and POJOs) for insertion and search operations, highlighting the trade-offs between speed, memory usage, and simplicity.

Related benchmarks:

Inserting and Searching in Map vs Object (version: 0)

Compares insert & search operations with Map vs. POJOs

Comparing performance of: Insert in small Map vs insert in small POJO vs Insert in large Map vs Insert in large POJO vs Search in small Map vs Search in small POJO vs Search in large Map vs Search in large POJO

Created: 5 years ago by: Guest

Jump to the latest result

Insert in small Map

insert in small POJO

Insert in large Map

Insert in large POJO

Search in small Map

Search in small POJO

Search in large Map

Search in large POJO

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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