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]); }

Historical Performance Data aggregated from 22 community runs

Desktop Results:

Chrome 22 runs

Lodash keyBy (10k entries)

3K/s

JS Map (10k entries)

2K/s

JS Map (100k entries)

204/s

Lodash keyBy (100k entries)

160/s

Fastest: Lodash keyBy (10k entries) (17.0x faster)

View exact numbers

✓ Lodash keyBy (10k entries): 2,710 ops/sec
• JS Map (10k entries): 2,426 ops/sec
• JS Map (100k entries): 204 ops/sec
• Lodash keyBy (100k entries): 160 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: 10 months ago)

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

Browser/OS: Chrome 139 on Mac OS X 10.15.7

View result in a separate tab

JS Map (10k entries)

4K/s

Lodash keyBy (10k entries)

4K/s

JS Map (100k entries)

268/s

Lodash keyBy (100k entries)

222/s

View exact numbers

Test name	Executions per second
✓ JS Map (10k entries)	4,482 Ops/sec
Lodash keyBy (10k entries)	3,674 Ops/sec
JS Map (100k entries)	268 Ops/sec
Lodash keyBy (100k entries)	222 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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: 3 years ago by: Registered User

Go to the latest result

Lodash keyBy (10k entries)

JS Map (10k entries)

Lodash keyBy (100k entries)

JS Map (100k entries)

Historical Performance Data aggregated from 22 community runs

Desktop Results:

Chrome 22 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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: 3 years ago by: Registered User

Go to the latest result

Lodash keyBy (10k entries)

JS Map (10k entries)

Lodash keyBy (100k entries)

JS Map (100k entries)

Historical Performance Data aggregated from 22 community runs

Desktop Results:

Chrome 22 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

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