Benchmark: Lodash keyBy vs JS Map (with small and large size)

Script Preparation code:

window.data = [];
for (let i = 0; i < 10000; i++) {
    data.push({
        key: `key${i}`
    });
}

window.dataBig = [];
for (let i = 0; i < 100000; i++) {
    dataBig.push({
        key: `key${i}`
    });
}

Tests:

Lodash keyBy (10k entries)
const keyed = _.keyBy(data, v => v.key)
JS Map (10k entries)
const map = new Map(); for (let i = 0; i < data.length; i++) { map.set(data[i].key, data[i]); }
Lodash keyBy (100k entries)
const keyed = _.keyBy(dataBig, v => v.key)
JS Map (100k entries)
const map = new Map(); for (let i = 0; i < dataBig.length; i++) { map.set(dataBig[i].key, dataBig[i]); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Lodash keyBy (10k entries)
JS Map (10k entries)
Lodash keyBy (100k entries)
JS Map (100k entries)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 18 days ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Lodash keyBy (10k entries)	2318.3 Ops/sec
JS Map (10k entries)	388.5 Ops/sec
Lodash keyBy (100k entries)	119.8 Ops/sec
JS Map (100k entries)	35.8 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks, comparing the performance of different approaches on various platforms.

The provided benchmark definition json represents a test case that measures the performance of two approaches: Lodash's `keyBy` function and JavaScript's built-in `Map` data structure. The test creates an array of 10,000 objects with a unique key for each object and another array of 100,000 objects with the same properties.

**Benchmark Definition**

The benchmark definition json consists of three main parts:

1. **Script Preparation Code**: This code initializes two arrays, `data` and `dataBig`, containing 10,000 and 100,000 objects, respectively. Each object has a unique key in the format "keyX", where X is an incrementing number.
2. **Html Preparation Code**: There is no HTML preparation code provided, indicating that this test only measures JavaScript performance without considering DOM-related overhead.
3. **Benchmark Definition**: The benchmark definition consists of four individual test cases:
	* `Lodash keyBy (10k entries)`: Measures the performance of Lodash's `keyBy` function on a smaller dataset of 10,000 objects.
	* `JS Map (10k entries)`: Measures the performance of JavaScript's built-in `Map` data structure on a smaller dataset of 10,000 objects.
	* `Lodash keyBy (100k entries)`: Measures the performance of Lodash's `keyBy` function on a larger dataset of 100,000 objects.
	* `JS Map (100k entries)`: Measures the performance of JavaScript's built-in `Map` data structure on a larger dataset of 100,000 objects.

**Options Compared**

The two main options compared in this benchmark are:

1. **Lodash keyBy**: A function that takes an array and a mapping function as input and returns a new object with the mapped values.
2. **JavaScript Map**: A built-in data structure that stores key-value pairs.

Both approaches aim to achieve similar results: iterating over the input array, extracting the key from each object, and storing the value in a new data structure (either an object or a `Map`).

**Pros and Cons**

Here are some pros and cons of each approach:

**Lodash keyBy**

Pros:

* Concise and readable code
* Well-tested and maintained library

Cons:

* Additional dependency on Lodash library
* May have overhead due to function calls and object creation

**JavaScript Map**

Pros:

* Built-in data structure, no additional dependency required
* Efficient iteration and lookup operations

Cons:

* May require more manual bookkeeping (e.g., handling keys and values)
* Less readable code compared to `keyBy`

**Other Considerations**

1. **Memory allocation**: Both approaches allocate memory for the resulting object or map. However, Lodash's `keyBy` might have overhead due to creating an intermediate object, whereas JavaScript's `Map` directly stores key-value pairs in contiguous memory.
2. **Iteration order**: JavaScript's `Map` iteration is typically slower than Lodash's `keyBy`, as it requires explicit ordering of keys and values.

**Libraries**

1. **Lodash**: A popular utility library for JavaScript, providing various functions for data manipulation, string manipulation, and more.

**Special JS Features/Syntax**

None mentioned in this benchmark definition.

Related benchmarks:

Lodash keyBy vs JS Map (with small and large size) (version: 1)

Comparing performance of: Lodash keyBy (10k entries) vs JS Map (10k entries) vs Lodash keyBy (100k entries) vs JS Map (100k entries)

Created: one year ago by: Registered User

Jump to the latest result

Lodash keyBy (10k entries)

JS Map (10k entries)

Lodash keyBy (100k entries)

JS Map (100k entries)

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