Benchmark: Object vs Map (Insert, Delete and Copy)

Script Preparation code:

var map = new Map();
var obj = {};
var obj2 = Object.create(null);

AخA
 
var map = new Map();var obj = {};var obj2 = Object.create(null);

Tests:

Map Insert

for (let i = 0; i < 10000; i++) {
	map.set(`a${i}`, i); 
}

 
for (let i = 0; i < 10000; i++) {    map.set(`a${i}`, i); }

Object Insert

for (let i = 0; i < 10000; i++) {
	obj[`a${i}`] = i; 
}

 
for (let i = 0; i < 10000; i++) {    obj[`a${i}`] = i; }

Object2 Insert

for (let i = 0; i < 10000; i++) {
	obj2[`a${i}`] = i; 
}

 
for (let i = 0; i < 10000; i++) {    obj2[`a${i}`] = i; }

Map Delete

let map = new Map();
for (let i = 0; i < 10000; i++) {
	map.delete(`a${i}`); 
}

 
let map = new Map();for (let i = 0; i < 10000; i++) {    map.delete(`a${i}`); }

Object Delete

for (let i = 0; i < 10000; i++) {
	delete obj[`a${i}`]; 
}

 
for (let i = 0; i < 10000; i++) {    delete obj[`a${i}`]; }

Object2 Delete

for (let i = 0; i < 10000; i++) {
	delete obj2[`a${i}`]; 
}

 
for (let i = 0; i < 10000; i++) {    delete obj2[`a${i}`]; }

Map Copy

for (let i = 0; i < 10000; i++) {
	const map2 = new Map(map); 
}

 
for (let i = 0; i < 10000; i++) {    const map2 = new Map(map); }

Object Copy

for (let i = 0; i < 10000; i++) {
	const objCopy = {...obj};
}

 
for (let i = 0; i < 10000; i++) {    const objCopy = {...obj};}

Object2 Copy

for (let i = 0; i < 10000; i++) {
	const objCopy = {...obj2};
}

 
for (let i = 0; i < 10000; i++) {    const objCopy = {...obj2};}

Map to Object

for (let i = 0; i < 10000; i++) {
	const newObj = Object.fromEntries(map.entries()); 
}

 
for (let i = 0; i < 10000; i++) {    const newObj = Object.fromEntries(map.entries()); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Map Insert
Object Insert
Object2 Insert
Map Delete
Object Delete
Object2 Delete
Map Copy
Object Copy
Object2 Copy
Map to Object

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 103 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Map Insert	1229.8 Ops/sec
Object Insert	1052.9 Ops/sec
Object2 Insert	1053.2 Ops/sec
Map Delete	5714.5 Ops/sec
Object Delete	1046.2 Ops/sec
Object2 Delete	1353.9 Ops/sec
Map Copy	0.2 Ops/sec
Object Copy	875.2 Ops/sec
Object2 Copy	880.7 Ops/sec
Map to Object	0.1 Ops/sec

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

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested in this particular benchmark.

Benchmark Overview

This benchmark compares the performance of three data structures: Object, Map, and Object2 (a variant of Object). Each test case measures the execution time of various operations:

Insertion
Deletion
Copying

The benchmarks aim to determine which data structure is most efficient for these common use cases.

Data Structures

Let's take a closer look at each data structure being compared:

Object: A traditional JavaScript object, represented by the obj variable.
Map: A JavaScript Map object, represented by the map variable. Maps are similar to objects but offer additional methods and features like key-value pairs and efficient iteration.
Object2 (variant of Object): An alternative implementation of an object, represented by the obj2 variable. This variant is not a standard JavaScript object.

Benchmark Operations

Each test case measures the execution time for one or more operations:

Insertion:
- Object insertion: obj[key] = value
- Map insertion: map.set(key, value)
- Object2 insertion: obj2[key] = value (assuming a custom implementation)
Deletion:
- Object deletion: delete obj[key]
- Map deletion: map.delete(key)
Copying:
- Object copying: const copiedObj = { ... obj }
- Map copying: const copiedMap = new Map([...map])
Map to Object: Converting a Map to an equivalent Object. This operation is not directly applicable to Object2.

Performance Comparison

The benchmark outputs the execution time for each test case, providing insights into which data structure performs best under various scenarios.

In this benchmark:

Map consistently outperforms both Object and Object2 in terms of insertion, deletion, and copying operations.
Object2, being a variant of Object, doesn't seem to offer significant performance advantages over the traditional Object.

Keep in mind that these results may depend on specific use cases and implementation details. The benchmark is likely designed to highlight the strengths of JavaScript's built-in Map data structure.

Please let me know if you have any further questions or if there's anything else I can help with!

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested in this particular benchmark.

**Benchmark Overview**

This benchmark compares the performance of three data structures: `Object`, `Map`, and `Object2` (a variant of `Object`). Each test case measures the execution time of various operations:

1. Insertion
2. Deletion
3. Copying

The benchmarks aim to determine which data structure is most efficient for these common use cases.

**Data Structures**

Let's take a closer look at each data structure being compared:

* **Object**: A traditional JavaScript object, represented by the `obj` variable.
* **Map**: A JavaScript Map object, represented by the `map` variable. Maps are similar to objects but offer additional methods and features like key-value pairs and efficient iteration.
* **Object2** (variant of Object): An alternative implementation of an object, represented by the `obj2` variable. This variant is not a standard JavaScript object.

**Benchmark Operations**

Each test case measures the execution time for one or more operations:

1. Insertion:
	* `Object` insertion: `obj[key] = value`
	* `Map` insertion: `map.set(key, value)`
	* `Object2` insertion: `obj2[key] = value` (assuming a custom implementation)
2. Deletion:
	* `Object` deletion: `delete obj[key]`
	* `Map` deletion: `map.delete(key)`
3. Copying:
	* `Object` copying: `const copiedObj = { ... obj }`
	* `Map` copying: `const copiedMap = new Map([...map])`
4. `Map to Object`: Converting a `Map` to an equivalent `Object`. This operation is not directly applicable to `Object2`.

**Performance Comparison**

The benchmark outputs the execution time for each test case, providing insights into which data structure performs best under various scenarios.

In this benchmark:

* **Map** consistently outperforms both `Object` and `Object2` in terms of insertion, deletion, and copying operations.
* **Object2**, being a variant of Object, doesn't seem to offer significant performance advantages over the traditional `Object`.

Keep in mind that these results may depend on specific use cases and implementation details. The benchmark is likely designed to highlight the strengths of JavaScript's built-in `Map` data structure.

Please let me know if you have any further questions or if there's anything else I can help with!

Related benchmarks:

Object vs Map (Insert, Delete and Copy) (version: 0)

Comparing performance of: Map Insert vs Object Insert vs Object2 Insert vs Map Delete vs Object Delete vs Object2 Delete vs Map Copy vs Object Copy vs Object2 Copy vs Map to Object

Created: 2 years ago by: Guest

Jump to the latest result

Map Insert

Object Insert

Object2 Insert

Map Delete

Object Delete

Object2 Delete

Map Copy

Object Copy

Object2 Copy

Map to Object

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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