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>

AخA
 
<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; }

​x
 
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}
const obj1 = {mamka: 'big', jopa: 'fat'}
const obj2 = {...obj1}
Object.assign
const obj1 = {mamka: 'big', jopa: 'fat'} const obj2 = Object.assign({}, obj1)
const obj1 = {mamka: 'big', jopa: 'fat'}
const obj2 = Object.assign({}, obj1)

_.extend

const obj1 = {mamka: 'big', jopa: 'fat'}
const obj2 = _.extend({}, obj1)

 
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'})
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);
var obj1 = {
mamka: 'big',
jopa: 'fat'
};

var obj2 = _objectSpread({}, obj1);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

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: 3 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 7 months ago):

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:

"Object spread"
"Object.assign"
"_extend" (a function from Lodash)
"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:

Immutable.js (version 4.0.0-rc.12) - a library for working with immutable data structures.
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:

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.

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.

_.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.

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.

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.

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: 6 years ago by: Registered User

Jump to the latest result

Object spread

Object.assign