Benchmark: map+array.from vs object iteration

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/lodash@4.17.15/lodash.min.js"></script>

Tests:

map + array.from
let myMap = new Map(); myMap.set('1', 'asd1'); myMap.set('2', 'asd2'); myMap.set('3', 'asd3'); myMap.set('4', 'asd4'); myMap.set('5', 'asd5'); myMap.set('6', 'asd6'); var keyArr = Array.from(myMap.keys()); var valArr = Array.from(myMap.values()); myMap.delete('1'); myMap.delete('2'); keyArr = Array.from(myMap.keys()); valArr = Array.from(myMap.values());
object iteration
var myObj = [ {key: '1', value: 'asd1'}, {key: '2', value: 'asd2'}, {key: '3', value: 'asd3'}, {key: '4', value: 'asd4'}, {key: '5', value: 'asd5'}, {key: '6', value: 'asd6'}, ]; var delEle = ['1', '2']; var rem; delEle.forEach(function(del) { rem = _.remove(myObj, function(objj) { return objj.key == del; }); });

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
map + array.from
object iteration

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36

Browser/OS: Chrome 79 on Windows

View result in a separate tab

Test name	Executions per second
map + array.from	879352.6 Ops/sec
object iteration	1160617.2 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 benchmark definition and test cases.

**Overall Context**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The goal of this benchmarking tool is to compare the performance of different approaches in JavaScript, helping developers optimize their code for better performance.

**Benchmark Definition JSON**

The benchmark definition is an object that contains metadata about the benchmark, such as its name, description, script preparation code, and HTML preparation code. In this case:

* The benchmark is named "map+array.from vs object iteration".
* It does not have a description.
* The script preparation code is empty.
* The HTML preparation code includes a reference to the Lodash library.

**Individual Test Cases**

The benchmark consists of two individual test cases, each with its own `Benchmark Definition` string. These strings describe the specific JavaScript code that will be executed in each test case.

### Test Case 1: "map + array.from"

This test case creates a new Map object and sets several key-value pairs on it. It then uses `Array.from()` to extract the keys and values from the map, deletes two items from the map, and extracts the remaining keys and values using `Array.from()`. Finally, it deletes two more items from the map.

### Test Case 2: "object iteration"

This test case creates an array of objects with key-value pairs. It then uses Lodash's `remove()` function to delete two specific objects from the array based on their keys. The code also includes a loop that iterates over an array of keys and deletes the corresponding object from the array.

**Library Used: Lodash**

In Test Case 2, the code references the Lodash library, which is a popular utility library for JavaScript. In this specific case, the `remove()` function is used to delete objects from the array based on their keys.

**Special JS Feature or Syntax: None**

Neither of the test cases uses any special JavaScript features or syntax that requires explanation beyond what's provided in the benchmark definition.

**Performance Comparison**

The benchmark aims to compare the performance of two approaches:

1. Using a Map object with `Array.from()` to extract keys and values.
2. Iterating over an array of objects using Lodash's `remove()` function.

**Pros and Cons of Each Approach**

* **Map + Array.from:**
	+ Pros:
		- Efficiently extracts keys and values from the map using `Array.from()`.
		- Can be faster for large datasets.
	+ Cons:
		- May not work as expected if the map is modified after extraction (e.g., items are deleted).
* **Object iteration with Lodash's remove():**
	+ Pros:
		- Works even when the array of objects changes during execution.
	+ Cons:
		- May be slower than `Map + Array.from` for large datasets.

**Other Alternatives**

There may be other approaches to achieve similar results, such as:

* Using a Set object instead of an array of objects
* Utilizing native JavaScript methods like `forEach()` or `filter()`
* Implementing custom loop-based iteration

However, without more context and specific requirements, it's difficult to determine the most suitable alternative for this particular benchmark.

Related benchmarks:

map+array.from vs object iteration (version: 0)

Comparing performance of: map + array.from vs object iteration

Created: 4 years ago by: Registered User

Jump to the latest result

map + array.from

object iteration

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):