Benchmark: Map vs Object (3)

Script Preparation code:

var map = new Map();
var obj = {};

var i = 0,
    count = 100000,
    a;

function getKey(i) {
    return `i-${i}`;
}

// set default values
for (i = 0; i < count; i++) {
    var key = getKey(i);
    var value = {
        i,
        key
    };
    map.set(key, value);
    obj[key] = value;
}

Tests:

Map get
for (i = 0; i < count; i++) { a = map.get(getKey(i)); }
Obj get
for (i = 0; i < count; i++) { a = obj[getKey(i)]; }
Map set
for (i = 0; i < count; i++) { var value = { i, key }; map.set(getKey(i + count), value); }
Obj set
for (i = 0; i < count; i++) { var value = { i, key }; obj[getKey(i + count)] = value; }
Map get after all
for (i = 0; i < count * 2; i++) { a = map.get(getKey(i)); }
Obj get after all
for (i = 0; i < count * 2; i++) { a = obj[getKey(i)]; }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Map get
Obj get
Map set
Obj set
Map get after all
Obj get after all

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:147.0) Gecko/20100101 Firefox/147.0

Browser/OS: Firefox 147 on Windows

View result in a separate tab

Test name	Executions per second
Map get	43.4 Ops/sec
Obj get	37.5 Ops/sec
Map set	31.4 Ops/sec
Obj set	30.1 Ops/sec
Map get after all	17.1 Ops/sec
Obj get after all	14.8 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Explanation**

The provided benchmark tests the performance of JavaScript objects (specifically, Maps) compared to plain JavaScript objects in various scenarios.

The main data structure used is a Map, which is a collection of key-value pairs. In this benchmark, we have two types of objects: a Map (`map`) and a plain object (`obj`). We'll compare their behavior when it comes to:

1. **Lookup**: Retrieving values from the Map or object using a specific key.
2. **Insertion**: Adding new entries to the Map or object.

**Options Compared**

There are two main options being compared:

1. **Map (JavaScript)**: The built-in `Map` data structure in JavaScript, which provides a fast and efficient way to store and retrieve key-value pairs.
2. **Plain Object (JavaScript)**: A regular JavaScript object, which is an associative array of key-value pairs.

**Pros and Cons**

Here's a brief summary of the pros and cons of each option:

* **Map**:
	+ Pros:
		- Fast lookups ( O(1) average case)
		- Efficient insertion and removal of entries
		- Provides useful methods like `get()`, `set()`, and `delete()`
	+ Cons:
		- Not all browsers support the built-in Map data structure.
		- Can be slower for large datasets due to its inherent object nature.
* **Plain Object**:
	+ Pros:
		- Wide browser support
		- Can be faster for very large datasets, as objects don't store keys in a separate data structure.
	+ Cons:
		- Slower lookups ( O(1) average case) compared to Map
		- Less efficient insertion and removal of entries

**Library Usage**

There is no explicit library mentioned in the benchmark definition. However, some browsers might include internal libraries that support the built-in Map data structure.

**Special JavaScript Features/Syntax**

The benchmark uses a few special features:

* **Template literals**: Used to create string templates with variables (`${i}`).
* **Arrow functions**: Used as shorthand for function declarations (`function getKey(i) { ... }`).

**Other Alternatives**

If you're interested in exploring alternative data structures or approaches, here are some options:

* **WeakMap**: A variant of Map that only allows one-way access from keys to values.
* **Set**: An unordered collection of unique values, which can be used for fast membership testing and insertion removal.
* **Native Indexed Arrays**: Some browsers provide native support for indexed arrays, which can offer better performance than objects or Maps in certain scenarios.

Keep in mind that the choice of data structure ultimately depends on your specific use case and requirements.

Related benchmarks:

Map vs Object (3) (version: 0)

Lookup of map vs object

Comparing performance of: Map get vs Obj get vs Map set vs Obj set vs Map get after all vs Obj get after all

Created: 3 years ago by: Guest

Jump to the latest result

Map get

Obj get

Map set

Obj set

Map get after all

Obj get after all

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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