Benchmark: Cloning. - MeasureThat.net

Script Preparation code:

const size = 10000;
var obj = {};
var set = new Set();
var map = new Map();
var arr = [];

for (let i=0; i < size; i++) {
  const item = `item${i}`;
  obj[item] = true;
  set.add(item);
  map.set(item, true);
  arr.push(item);
 
}

Tests:

obj
let copy = {...obj} delete copy.item5000
set
let copy = new Set(set) copy.delete("item5000")
map
let copy = new Map(map) copy.set("item5000", undefined);
array
let copy = [...arr] copy[5000] = undefined;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
obj
set
map
array

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/111.0.0.0 Safari/537.36

Browser/OS: Chrome 111 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
obj	439.1 Ops/sec
set	2209.1 Ops/sec
map	1753.0 Ops/sec
array	434808.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what is being tested, compared, and their pros and cons.

**Benchmark Definition**

The benchmark definition json represents the initial setup for the test cases. It defines:

1. `Name` and `Description`: These are metadata fields that provide a name and description for the benchmark.
2. `Script Preparation Code`: This code snippet is executed before running each test case. It creates various data structures (an object, set, map, and array) with 10,000 items, where each item is a unique string.

The purpose of this script preparation code is to provide a common baseline for all test cases, ensuring that they have similar input data.

**Individual Test Cases**

Each test case has a `Benchmark Definition` field that represents the actual benchmarking logic. The test cases compare different aspects of the data structures created in the script preparation code:

1. **obj**: Tests cloning an object using the spread operator (`{...obj}`) and then deleting a specific item from the cloned copy.
	* Pros: Simple and efficient way to clone objects. Modern JavaScript engines are optimized for this operation.
	* Cons: Not all objects support cloning, and some might create shallow copies if not implemented correctly.
2. **set**: Tests creating a set using another set (`new Set(set)`) and then removing an item from the cloned copy.
	* Pros: Fast and efficient way to create sets. Modern JavaScript engines are optimized for this operation.
	* Cons: Sets do not support direct deletion of items like arrays or objects do; instead, you need to remove the item using `delete` keyword or by replacing it with `undefined`.
3. **map**: Tests creating a map using another map (`new Map(map)`) and then setting an undefined value for a specific key.
	* Pros: Fast and efficient way to create maps. Modern JavaScript engines are optimized for this operation.
	* Cons: Maps do not support direct deletion of keys like arrays or objects do; instead, you need to remove the key using `delete` keyword or by replacing it with `undefined`.
4. **array**: Tests cloning an array (`[...arr]`) and then setting an undefined value at a specific index.
	* Pros: Fast and efficient way to clone arrays. Modern JavaScript engines are optimized for this operation.
	* Cons: Not all arrays support cloning; instead, you need to use `Array.prototype.slice()` or other methods.

**Library Usage**

In the provided test cases, no external libraries are used explicitly. However, it's essential to note that modern JavaScript engines often rely on internal libraries and optimizations under the hood.

**Special JS Features or Syntax**

The provided benchmarking code uses some ES6+ features like:

* Template literals (`const item = `item${i}`;\r\n`)
* Spread operator (`{...obj}`)
* New Set and Map constructors (`new Set(set)` and `new Map(map)`)
* Destructuring assignment (not explicitly used in this example, but implied)

These features are part of the modern JavaScript language specification.

**Alternatives**

If you wanted to write alternative implementations for these test cases, here are some suggestions:

1. **obj**: You could use a library like Lodash's `cloneDeep` or `pickBy` to clone objects.
2. **set**: Instead of using another set, you could create an array and then remove the item from it using `splice()` or `indexOf()`.
3. **map**: Similar to sets, you could create an array and then remove the key by replacing it with `undefined`.
4. **array**: You could use a library like Lodash's `cloneDeep` to clone arrays.

Keep in mind that these alternatives might not be as efficient or modern as using built-in JavaScript operations.

Related benchmarks:

Cloning. (version: 0)

Comparing performance of: obj vs set vs map vs array

Created: one year ago by: Registered User

Jump to the latest result

obj

set

map

array

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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