Benchmark: pairs to object - 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 = [
  ['a', 1],
  ['b', 2],
  ['c', 3],
  ['d', 4],
  ['e', 5],
  ['f', 6],
  ['g', 7],
  ['h', 8],
  ['i', 9],
  ['j', 0],
  ]

Tests:

object assign + new object
var result = arr.reduce((prev, curr) => Object.assign( {}, prev, { [curr[0]]: curr[1] }, ))
object assign
var result = arr.reduce((prev, curr) => Object.assign( prev, { [curr[0]]: curr[1] }, ))
arr reduce + simple set
var result = arr.reduce((prev, curr) => { prev[curr[1]] = curr[2]; return prev; })
arr reduce + spread
var result = arr.reduce((prev, curr) => ({ ...prev, [curr[0]]: curr[1], }))
fromPairs
var result = _.fromPairs(arr);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
object assign + new object
object assign
arr reduce + simple set
arr reduce + spread
fromPairs

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 68 on Windows

View result in a separate tab

Test name	Executions per second
object assign + new object	36868.6 Ops/sec
object assign	228096.7 Ops/sec
arr reduce + simple set	6187765.5 Ops/sec
arr reduce + spread	16885.0 Ops/sec
fromPairs	1625631.2 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 benchmarks!

**Benchmark Definition JSON**

The provided JSON represents a benchmark definition, which is a set of instructions for creating and running a test case. In this case, we have two main components:

1. **Script Preparation Code**: This section contains the initial JavaScript code that will be executed before each test case. In this example, it's a simple array `arr` with key-value pairs.
2. **Html Preparation Code**: This section includes an external script reference for the popular utility library Lodash.js (version 4.17.5). Lodash provides various helper functions for tasks like object manipulation, which is likely what these benchmarks aim to test.

**Individual Test Cases**

We have six test cases, each with its own benchmark definition:

1. **"object assign + new object"`**: Tests the `Object.assign()` method with a new object as the target.
2. **"object assign"`**: Tests only the `Object.assign()` method without creating a new object.
3. **"arr reduce + simple set"`**: Uses the `Array.prototype.reduce()` method to create an object with simple key-value pairs.
4. **"arr reduce + spread"`**: Utilizes the `Array.prototype.reduce()` method with the spread operator (`...`) to create an object with spread key-value pairs.
5. **"fromPairs"`**: Leverages Lodash's `_fromPairs()` function to create an object from a two-dimensional array (key-value pairs).
6. **"object assign + new object"`**: Similar to the first test case, but this time using `Object.assign()` with a new object as the target.

**Options Compared**

These tests compare different approaches to creating objects from key-value pairs:

* Using `Object.assign()` with an existing object (`"object assign"` and `"object assign + new object"`).
* Utilizing `Array.prototype.reduce()` with simple key-value pairs (`"arr reduce + simple set"`).
* Using `Array.prototype.reduce()` with spread key-value pairs (`"arr reduce + spread"`).
* Leveraging Lodash's `_fromPairs()` function (`"fromPairs"`).

**Pros and Cons of Each Approach**

Here's a brief summary of the pros and cons of each approach:

1. **`Object.assign()`**: Pros: Simple, efficient, and widely supported. Cons: Can be slower than other approaches for large datasets.
2. **`Array.prototype.reduce()` with simple key-value pairs**: Pros: Flexible, allows for custom iteration logic. Cons: May require more memory and processing power compared to `Object.assign()`.
3. **`Array.prototype.reduce()` with spread key-value pairs**: Pros: Similar to the previous approach but uses the spread operator, which can be beneficial for object literals. Cons: Can still lead to slower performance due to the use of reduce.
4. **Lodash's `_fromPairs()` function**: Pros: Convenient, efficient, and handles edge cases. Cons: Requires an external library (Lodash).

**Special JS Features or Syntax**

The tests do not explicitly mention any special JavaScript features or syntax. However, they do utilize the `Array.prototype.reduce()` method, which is a built-in feature.

**Other Alternatives**

If you're interested in exploring alternative approaches, here are some options:

1. **Using `Object.keys()` and `reduce()`**: Another way to create an object from key-value pairs using `Object.keys()` and the `reduce()` method.
2. **Utilizing libraries like Underscore.js or Moment.js**: These libraries provide various utility functions for tasks like object manipulation, which might be of interest if you want to explore other approaches.

In conclusion, these benchmarks test different methods for creating objects from key-value pairs in JavaScript, highlighting the importance of choosing the most efficient and suitable approach depending on your specific use case.

Related benchmarks:

pairs to object (version: 0)

Comparing performance of: object assign + new object vs object assign vs arr reduce + simple set vs arr reduce + spread vs fromPairs

Created: 6 years ago by: Guest

Jump to the latest result

object assign + new object

object assign

arr reduce + simple set

arr reduce + spread

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