Benchmark: Object creation - MeasureThat.net

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/immutable/4.0.0-rc.12/immutable.min.js'></script>
<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

Tests:

Object spread
const obj1 = {mamka: 'big', jopa: 'fat'} const obj2 = {...obj1}
Object.assign
const obj1 = {mamka: 'big', jopa: 'fat'} const obj2 = Object.assign({}, obj1)
_.extend
const obj1 = {mamka: 'big', jopa: 'fat'} const obj2 = _.extend({}, obj1)
immutable record
const rec1 = Immutable.Record({mamka: 'big', jopa: 'fat'}); const rec2 = rec1({mamka: 'small', jopa: 'thin'})
Babelified spread
var obj1 = { mamka: 'big', jopa: 'fat' }; var obj2 = _objectSpread({}, obj1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object spread
Object.assign
_.extend
immutable record
Babelified spread

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 99 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object spread	65100160.0 Ops/sec
Object.assign	5850857.0 Ops/sec
_.extend	2643322.0 Ops/sec
immutable record	161685.9 Ops/sec
Babelified spread	979098.4 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 on MeasureThat.net.

**Benchmark Definition**

The benchmark definition is a JSON object that describes the test case being run. In this case, we have four individual test cases:

1. "Object spread"
2. "Object.assign"
3. "_extend" (a function from Lodash)
4. "immutable record"

Each test case has a brief description and two code snippets: a script preparation code and an HTML preparation code.

**Script Preparation Code**

The script preparation code is a JavaScript function that sets up the environment for each test case. In this case, we have:

* `_objectSpread` function (a custom implementation of object spread)
* `_defineProperty` function (another custom implementation)

These functions are used to create objects and manipulate their properties.

**Html Preparation Code**

The HTML preparation code includes two external scripts:

1. Immutable.js (version 4.0.0-rc.12) - a library for working with immutable data structures.
2. Lodash.js (version 4.17.5) - a utility library that provides functions for tasks like array manipulation and object creation.

**Test Cases**

Let's analyze each test case:

1. **Object spread**: This test case creates an initial object `obj1` with two properties: `mamka` and `jopa`. Then, it creates a new object `obj2` by spreading the properties of `obj1` using the `_objectSpread` function.

Pros: Simple and straightforward implementation.
Cons: May not be as efficient as other methods due to the custom implementation.

2. **Object.assign**: This test case also creates an initial object `obj1` with two properties: `mamka` and `jopa`. Then, it creates a new object `obj2` by assigning the properties of `obj1` using the `Object.assign()` method.

Pros: Widely supported and efficient.
Cons: May not work as expected if the source object has circular references or other issues.

3. **_.extend**: This test case uses the `_extend` function from Lodash to create a new object by extending an initial object `obj1`.

Pros: Easy to use and works well with many data structures.
Cons: May have performance overhead due to Lodash's complexity.

4. **Babelified spread**: This test case creates a new object by spreading the properties of an initial object `obj1` using the `_objectSpread` function from Babel.

Pros: Fast and efficient, thanks to Babel's optimization.
Cons: May not work as expected in older browsers or environments that don't support modern JavaScript features.

5. **Immutable record**: This test case uses Immutable.js to create a new object by creating an immutable record with two properties: `mamka` and `jopa`.

Pros: Efficient and predictable, thanks to Immutable.js's immutability.
Cons: May have higher overhead due to the need to clone objects.

**Other Considerations**

When choosing between these methods, consider factors like:

* Performance: Object.assign() and Babelified spread are generally fast, while _.extend may have performance overhead.
* Complexity: Immutable record has a predictable and efficient implementation, but it requires knowledge of Immutable.js.
* Browser support: Some older browsers may not support modern JavaScript features used in Babelified spread.

**Alternatives**

If you're looking for alternatives to these methods, consider:

* Using the `Object.create()` method instead of Object.assign()
* Utilizing libraries like underscore or moment.js for array and object manipulation
* Leverage modern JavaScript features like destructuring, spread operators, and async/await

Keep in mind that each approach has its strengths and weaknesses. MeasureThat.net's microbenchmarking can help you determine which method is best suited for your specific use case.

Related benchmarks:

Object creation (version: 1)

Comparing performance of: Object spread vs Object.assign vs _.extend vs immutable record vs Babelified spread

Created: 5 years ago by: Registered User

Jump to the latest result

Object spread

Object.assign

_.extend

immutable record

Babelified spread

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