Benchmark: Object.fromEntries vs lodash fromPairs

HTML Preparation code:

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

Tests:

Object.fromEntries
var a = [['a', 1], ['b', 2], ['c', 3]]; var b = Object.fromEntries(a);
_.fromPairs
var a = [['a', 1], ['b', 2], ['c', 3]]; var b = _.fromPairs(a);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.fromEntries
_.fromPairs

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Object.fromEntries	7346010.5 Ops/sec
_.fromPairs	23082926.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**What is being tested?**

The provided JSON represents a benchmark test between two approaches: `Object.fromEntries` and `lodash fromPairs`. The benchmark is designed to compare the performance of these two methods for converting an array of key-value pairs to an object.

**Options compared:**

* `Object.fromEntries`: A built-in JavaScript method introduced in ECMAScript 2017, which converts an iterable of key-value pairs to an object.
* `lodash fromPairs`: A utility function from the popular Lodash library, which achieves the same result as `Object.fromEntries`.

**Pros and Cons:**

* **`Object.fromEntries`**:
	+ Pros: Built-in method, efficient, and widely supported across browsers and Node.js versions.
	+ Cons: May have slower performance compared to optimized libraries like Lodash.
* **`lodash fromPairs`**:
	+ Pros: Optimized for performance, compatible with older browsers and Node.js versions, and often used in production code.
	+ Cons: Requires an external dependency (Lodash library) and may have a larger size overhead.

**Library:**

The `_.fromPairs` function is part of the Lodash library, which provides a comprehensive set of utility functions for JavaScript developers. The purpose of Lodash is to simplify common tasks and improve code readability by providing convenient functions for array manipulation, object creation, and more.

**Special JS feature or syntax:**

None mentioned in this benchmark test.

**Benchmark preparation code:**

The script preparation code includes an HTML link to include the Lodash library, which is required for the `_.fromPairs` function. The actual benchmark code is not provided, but it's likely that a simple array of key-value pairs is created and passed to both `Object.fromEntries` and `_.fromPairs` functions.

**Other alternatives:**

If you're interested in exploring other options, here are a few:

* **`Array.prototype.reduce()`**: Another built-in JavaScript method that can be used to create an object from an array of key-value pairs. However, this approach might have higher overhead due to the need to iterate over the array.
* **`Object.assign()`**: A built-in JavaScript function that can be used to merge objects, but it's not designed for creating an object from an array of key-value pairs.

Keep in mind that these alternatives might not provide the same performance as `Object.fromEntries` or optimized libraries like Lodash.

Related benchmarks:

Object.fromEntries vs lodash fromPairs (version: 0)

Comparing performance of: Object.fromEntries vs _.fromPairs

Created: 5 years ago by: Guest

Jump to the latest result

Object.fromEntries

_.fromPairs

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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