Benchmark: Object.assign vs for in vs Object.entries+for of vs spread

Script Preparation code:

var obj = {
  officeIpAddresses: [],
  customDomainHasUpdatedDns: false,
  stylePermissions: {
    styleAccess: {
      block: true,
      text: true,
      css: true,
      toolbar: true,
      motion: true,
    },
    editStyle: false,
  },
  permissions: {
    userInvitePermission: "test",
    defaultProjectAccess: "none",
  },
  notifications: {
    subscriptions: [],
    projectFirstOpen: true,
  },
  modules: {
    quote: {
    },
  },
};

Tests:

Object.assign
let newObj = Object.assign({}, obj)
for in
let newObj = {} for(let key in obj) { newObj[key] = obj[key] }
Object.keys + for of
let newObj = {} for(let key of Object.keys(obj)) { newObj[key] = obj[key] }
spread
let newObj = {...obj}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.assign
for in
Object.keys + for of
spread

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. In this explanation, we'll focus on the provided benchmark definition and test cases.

The benchmark compares four different approaches for assigning properties from an object to a new object:

1. `Object.assign()`
2. `for` loop with `in` keyword
3. Using `Object.keys()` and `for...of` loop
4. Spread operator (`...`)

**Benchmark Definition**

The benchmark definition is provided in JSON format, which includes the name of the benchmark, a description (empty in this case), script preparation code, and HTML preparation code.

```json
{
    "Name": "Object.assign vs for in vs Object.entries+for of vs spread",
    "Script Preparation Code": "...",
    "Html Preparation Code": null
}
```

**Individual Test Cases**

The benchmark consists of four individual test cases:

1. `Object.assign()`
2. `for` loop with `in` keyword
3. Using `Object.keys()` and `for...of` loop
4. Spread operator (`...`)

Each test case has a unique name, a corresponding `Benchmark Definition`, which includes the code snippet that runs each approach.

```json
[
    {
        "Benchmark Definition": "...",
        "Test Name": "Object.assign"
    },
    {
        "Benchmark Definition": "...",
        "Test Name": "for in"
    },
    {
        "Benchmark Definition": "...",
        "Test Name": "Object.keys + for of"
    },
    {
        "Benchmark Definition": "...",
        "Test Name": "spread"
    }
]
```

**Approach Comparison**

Here's a brief description of each approach and their pros and cons:

1. **`Object.assign()`**:
	* Pros: Concise, easy to read, and widely supported.
	* Cons: Can be slower due to the overhead of function calls.
2. **`for` loop with `in` keyword**:
	* Pros: Simple, well-supported, and fast.
	* Cons: May not work as expected in older browsers or versions.
3. **Using `Object.keys()` and `for...of` loop**:
	* Pros: More modern and efficient than the traditional `for` loop with `in`.
	* Cons: Requires support for newer JavaScript features (ECMAScript 2015+).
4. **Spread operator (`...`)**:
	* Pros: Concise, easy to read, and modern.
	* Cons: May not work as expected in older browsers or versions.

**Library and Special JS Features**

In the provided test case, `Object.assign()` is used with an object literal `{}` as its first argument. This is a common pattern for creating a shallow copy of an existing object.

No special JavaScript features are required for these test cases.

**Alternatives**

Other alternatives to achieve similar results include:

* Using `JSON.parse(JSON.stringify(obj))` instead of `Object.assign()`
* Using a library like Lodash (`_.cloneDeep()` or `_assign()`)
* Using a template literal (``object {...obj}```)

These alternatives may offer different trade-offs in terms of performance, conciseness, and readability.

**Conclusion**

The benchmark provides a concise comparison of four approaches for assigning properties from an object to a new object. Understanding the pros and cons of each approach can help developers choose the most suitable solution for their specific use cases.

Related benchmarks:

Object.assign vs for in vs Object.entries+for of vs spread (version: 1)

Comparing performance of: Object.assign vs for in vs Object.keys + for of vs spread

Created: 5 years ago by: Registered User

Jump to the latest result

Object.assign

for in

Object.keys + for of

spread

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):