Benchmark: Inserting and Searching in Map vs Object

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

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: 6 years ago by: Guest

Go to the latest result

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

Search in small Map

2.9M/s

Search in small POJO

159K/s

insert in small POJO

131K/s

Insert in small Map

74K/s

Search in large POJO

1K/s

Insert in large POJO

892/s

Search in large Map

348/s

Insert in large Map

214/s

View exact numbers

Test name	Executions per second
✓ Search in small Map	2,926,361 Ops/sec
Search in small POJO	159,294 Ops/sec
insert in small POJO	130,689 Ops/sec
Insert in small Map	73,796 Ops/sec
Search in large POJO	1,014 Ops/sec
Insert in large POJO	892 Ops/sec
Search in large Map	348 Ops/sec
Insert in large Map	214 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.