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

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

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

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 25 days ago):