Benchmark: lodash vs map 3 - MeasureThat.net

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

var arr = [];
var map = new Map();

for (let i = 1; i <= 10000; i++) {
    //let r = makeid(6);
    let r = Math.random().toString(36).substring(8);
    arr.push({
        r
    });
    map.set(r, {
        r
    });
}

Tests:

map
let smain = []; for (let s of map.values() ) { smain.push({r: s.r, r2: s.r + s.r}) }
lodash
let main = _.uniqBy(arr, 'r').map(ar => ({r: ar.r, r2: ar.r + ar.r}))
arr map
let newarr = Array.from(map); let newarr2 = []; newarr.forEach((s) => { newarr2.push({r: s.r, r2: s.r + s.r}) })
arr map2
let newarr = Array.from(map, s => ({r: s.r, r2: s.r + s.r}))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
map
lodash
arr map
arr map2

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Benchmark Definition**

The provided JSON defines a benchmark test case named "lodash vs map 3". This benchmark compares the performance of three different approaches:

1. **`map`**: Using the `Map` data structure in JavaScript to iterate over its values and create a new array.
2. **`arr map`**: Using the `Array.prototype.map()` method on the `arr` array to create a new array.
3. **`arr map2`**: Similar to `arr map`, but using the arrow function syntax.

**Options being compared**

The three options being compared are:

* Iterating over a `Map` data structure vs iterating over an `Array`
* Using the `Array.prototype.map()` method vs using the arrow function syntax

**Pros and Cons of each approach**

1. **`map` (iterating over a `Map`)**
	* Pros:
		+ Efficient use of memory, as it only stores unique keys.
		+ Fast iteration, as the `Map` data structure is optimized for iteration.
	* Cons:
		+ May have slower performance due to the overhead of creating and managing a `Map`.
		+ Requires more code and setup than using an `Array`.
2. **`arr map` (using `Array.prototype.map()`)**
	* Pros:
		+ Fast iteration, as the `Array.prototype.map()` method is optimized for performance.
		+ Simple to implement and use.
	* Cons:
		+ May have slower performance due to the overhead of creating a new array.
		+ Requires more memory, as it creates a new array.
3. **`arr map2` (using arrow function syntax)**
	* Pros:
		+ Similar to `arr map`, but with improved code readability and conciseness.
		+ Still fast iteration, thanks to the optimized `Array.prototype.map()` method.

**Library: Lodash**

The benchmark uses Lodash, a popular JavaScript utility library, for its `uniqBy` function. Lodash provides a simple way to filter and transform arrays, making it easy to compare different approaches.

In this benchmark, Lodash is used to create an array of unique objects using the `uniqBy` function, which takes the `r` property as a key. The resulting array is then mapped over using the arrow function syntax (`ar => ({r: ar.r, r2: ar.r + ar.r})`).

**Special JS feature/syntax**

In this benchmark, the following special JavaScript features are used:

* **Arrow functions**: Used in the `arr map2` test case to simplify and conciseness of code.
* **Template literals**: Used in the benchmark script preparation code to create a random string (`let r = Math.random().toString(36).substring(8);`).

**Other alternatives**

If you're looking for alternative approaches, here are a few options:

* Using `Array.prototype.forEach()` instead of `Array.prototype.map()`
* Using a custom `for...of` loop or a library like Ramda to filter and transform the array
* Using a different data structure, such as an `Object` or a custom implementation, to iterate over.

However, it's worth noting that these alternatives may not be comparable in terms of performance, due to the specific use cases and optimizations used by each approach.

Related benchmarks:

lodash vs map 3 (version: 2)

Comparing performance of: map vs lodash vs arr map vs arr map2

Created: 5 years ago by: Registered User

Jump to the latest result

map

lodash

arr map

arr map2

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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