Benchmark: Map v Object v Set v Array ALL base actions

Script Preparation code:

var map = new Map();
var set = new Set();
var obj = {};
var weakMap = new WeakMap();
var weakSet = new WeakSet();

const arr = Array.from({
    length: 1000
}).map(v => Math.random() * 10000);

var arrString = arr.map(v => String(v) );

var arrObj = arr.map(v => Object.create(Object.prototype, {
  [v]: {value: v}
}));

var arrSymbol = arr.map(v => {
    return Symbol({
        [v]: v
    })
});

var mapPop = new Map(arrObj.map(v => [v, v]))
var setPop = new Set(arrObj);
var emptyMap = new Map();
var emptySet = new Set();
console.log(mapPop)

Tests:

map delete
mapPop.forEach(va => mapPop.delete(va))
set remove
setPop.forEach(va => setPop.delete(va))
add map
arrString.forEach(a => emptyMap.set(a, a))
add set
arrString.forEach(a => emptySet.add(a))
has Map
arrString.forEach(v => emptyMap.has(v))
has set
arrString.forEach(v => emptySet.has(v))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
map delete
set remove
add map
add set
has Map
has set

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases to understand what is being tested.

**Overview**

The benchmark measures the performance of various JavaScript data structures: `Map`, `Set`, `Array` (including derived types like `Object` and `Symbol`). The benchmark creates an array of 1000 random numbers, converts it to a string, and then uses these data structures for different operations.

**Benchmark Definition JSON**

The benchmark definition json includes:

* A script preparation code that initializes the data structures: `Map`, `Set`, `Array`, and derived types (`Object` and `Symbol`).
* An array of test cases, each with a unique `Benchmark Definition`.

**Test Cases**

The individual test cases measure the performance of specific operations on the created data structures:

1. `map delete`: Measures the time it takes to iterate over a `Map` and delete all entries.
2. `set remove`: Measures the time it takes to iterate over a `Set` and delete all elements.
3. `add map`: Measures the time it takes to add an entry to an empty `Map`.
4. `add set`: Measures the time it takes to add an element to an empty `Set`.
5. `has Map`: Measures the time it takes to check if a key exists in an empty `Map`.
6. `has set`: Measures the time it takes to check if an element exists in an empty `Set`.

**Library and Purpose**

The benchmark uses several libraries:

* None explicitly mentioned.

However, we can infer that the `Array.from` method is used to create an array from a specified length, and the `Object.create` method is used to create a new object with a specific prototype. These methods are built-in JavaScript functions or part of the ECMAScript standard.

**Special JS Features**

The benchmark does not explicitly use any special JavaScript features like async/await, Promises, or decorators.

**Options Compared**

The benchmark compares different approaches for each operation:

* Iterating over a `Map` and deleting entries
* Iterating over a `Set` and removing elements
* Adding an entry to a new `Map`
* Adding an element to a new `Set`
* Checking if a key exists in an empty `Map`
* Checking if an element exists in an empty `Set`

**Pros and Cons**

The pros and cons of each approach are not explicitly stated, but we can make some educated guesses:

* Iterating over a `Map` and deleting entries: Using the `forEach` method with a callback function might be efficient for small maps, but could lead to slower performance for larger maps due to the overhead of the callback function. Alternative approaches like using the `clear()` method or iterating directly on the key-value pairs might be faster.
* Iterating over a `Set` and removing elements: Using the `forEach` method with a callback function is likely to be efficient, as sets are designed for fast iteration.
* Adding an entry to a new `Map`: Using the `set()` method is likely to be efficient, as it involves only a simple lookup operation.
* Adding an element to a new `Set`: Using the `add()` method is likely to be efficient, as it involves only a simple addition operation.
* Checking if a key exists in an empty `Map`: The `has()` method is designed for this purpose and is likely to be efficient.
* Checking if an element exists in an empty `Set`: Similar to checking if a key exists in an empty `Map`, the `has()` method is designed for this purpose and is likely to be efficient.

**Alternatives**

If you're looking for alternatives or variations on these benchmarks, here are some ideas:

* Compare different data structures like `WeakMap` and `WeakSet`.
* Measure the performance of operations on larger or smaller arrays.
* Use a different browser or device platform to see how the results vary.
* Add additional operations, such as sorting or reversing, to the test cases.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:128.0) Gecko/20100101 Firefox/128.0

Browser/OS: Firefox 128 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
map delete	30866306.0 Ops/sec
set remove	31664146.0 Ops/sec
add map	14843.5 Ops/sec
add set	18199.4 Ops/sec
has Map	23248.4 Ops/sec
has set	22310.3 Ops/sec

Related benchmarks:

Map v Object v Set v Array ALL base actions (version: 4)

Comparing performance of: map delete vs set remove vs add map vs add set vs has Map vs has set

Created: 4 months ago by: Registered User

Jump to the latest result

map delete

set remove

add map

add set

has Map

has set

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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