Benchmark: merge preformance compare

HTML Preparation code:

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

Script Preparation code:

var a = {
        lastPrice: '1234.345',
        contractVal: 109,
        marginAsset: 'GET',
        baseAsset: 'ASG',
        quoteAsset: 'ASFE',
        quantityPrecision: 8,
        pricePrecision: 4,
        equalQtyPrecision: 6,
        tickSize: 0.001,
        limitStepSize: 0.001,
        marketStepSize: 0.01,
      };
var p = {
adl: 1234,
  askNotional: 2345236,
  bidNotional: 34636,
  collateral: 'AFE',
  marginAsset: 'EJG',
  cumRealized: 142565,
  entryPrice: 2356,
  id: '3452562',
  isolated: true,
  isolatedWallet: 1225,
  leverage: 23,
  markPrice: 34346,
  lastPrice: 567458,
  initialMarkPrice: 23456,
  notionalValue: 345346,
  positionSize: 45748,
  positionSide: 'ASGO',
  symbol: 'ASGT',
  unrealizedProfit: 1235,
  selectPrice: 12345,
  pushTime: 12435634578
}
var b = {
        collateral: 'ASDG',
        askNotional: 1245,
        bidNotional: 3467,
        cumRealized: 5736,
        entryPrice: 23567,
        isolatedWallet: 23536,
        markPrice: 23678,
        notionalValue: 347345,
        positionSize: 3245247,
        unrealizedProfit: 3477,
      };

Tests:

lodash merge
var c = _.merge({}, a, p, b);
Object.assign
var c = Object.assign({}, a, p, b);
spread
var c = {...a, ...p, ...c};

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash merge
Object.assign
spread

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

I'd be happy to help you understand the benchmark being tested on MeasureThat.net.

**Benchmark Definition**

The benchmark is defined by two scripts: `Script Preparation Code` and `Html Preparation Code`. The `Script Preparation Code` defines three test cases:

1. `merge`: Tests the performance of the `_` (Lodash) library's `merge()` function.
2. `Object.assign()`: Tests the performance of the built-in JavaScript `Object.assign()` method.
3. `spread`: Tests the performance of using the spread operator (`...`) to merge objects.

**Options Compared**

The benchmark compares the performance of three options:

1. **Lodash's `merge()` function**: This function takes multiple objects as arguments and returns a new object that contains all the properties from each input object.
2. **Built-in JavaScript `Object.assign()` method**: This method takes two or more objects as arguments and returns a new object that contains all the properties from each input object.
3. **Spread operator (`...`)**: This operator allows you to merge multiple objects into a single object.

**Pros and Cons of Each Approach**

Here's a brief summary:

1. **Lodash's `merge()` function**:
	* Pros: Can handle nested objects, supports complex merging logic.
	* Cons: Adds additional dependencies (Lodash library) and may not be familiar to all developers.
2. **Built-in JavaScript `Object.assign()` method**:
	* Pros: Built-in, no additional dependencies required, widely supported.
	* Cons: Limited support for nested objects, requires multiple arguments.
3. **Spread operator (`...`)**:
	* Pros: Simple, intuitive syntax, works with modern browsers and Node.js.
	* Cons: Limited support in older browsers and Node.js versions.

**Library Used**

The benchmark uses the Lodash library, which is a popular utility library for JavaScript that provides a variety of functions for tasks like array manipulation, object merging, and more. The `merge()` function is used to test its performance.

**Special JS Feature or Syntax**

None mentioned explicitly in the provided code snippets. However, it's worth noting that the use of Lodash suggests familiarity with modern JavaScript best practices and the importance of utility libraries for tasks like object merging.

**Other Alternatives**

If you need alternative implementations for the `merge()` function, you could consider using other libraries or frameworks that provide similar functionality, such as:

* **Underscore.js**: Another popular utility library for JavaScript.
* **Immutable.js**: A library for working with immutable data structures and functions.
* **Built-in JavaScript `reduce()` method**: While not exactly the same as merging objects, you could use `reduce()` to achieve a similar result.

Keep in mind that these alternatives may have different performance characteristics or trade-offs compared to Lodash's `merge()` function.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (iPhone; CPU iPhone OS 17_0_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1

Browser/OS: Mobile Safari 17 on iOS 17.0.2

View result in a separate tab

Test name	Executions per second
lodash merge	699868.7 Ops/sec
Object.assign	1723040.5 Ops/sec
spread	1609146.9 Ops/sec

Related benchmarks:

merge preformance compare (version: 0)

Comparing performance of: lodash merge vs Object.assign vs spread

Created: one year ago by: Guest

Jump to the latest result

lodash merge

Object.assign

spread

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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