Benchmark: iassign sequential vs nested calls

HTML Preparation code:

<script crossorigin src="https://unpkg.com/immutable-assign@2.0.4/deploy/iassign.js"></script>

AخA
 
<script crossorigin src="https://unpkg.com/immutable-assign@2.0.4/deploy/iassign.js"></script>

Script Preparation code:

var state = {
    hasChanged: false,
    name: 'Default state',
    tags: [],
    nested: {
        hasChanged: false,
        name: 'Default nested state',
        tags: [],
        nested: {
            hasChanged: false,
            name: '',
            tags: []
        },
        map: new Map()
    },
    map: new Map()
};

 
var state = {    hasChanged: false,    name: 'Default state',    tags: [],    nested: {        hasChanged: false,        name: 'Default nested state',        tags: [],        nested: {            hasChanged: false,            name: '',            tags: []        },        map: new Map()    },    map: new Map()};

Tests:

// sequential calls

const s7 = iassign(state, s => {
    s.hasChanged = true;
    return s;
});

const s8 = iassign(s7, s => s.nested, nested => {
    nested.hasChanged = true;
    return nested;
});

const s9 = iassign(s8, s => s.tags, tags => {
    tags.push('new tag');
    return tags;
});

​x
 
const s7 = iassign(state, s => {    s.hasChanged = true;    return s;});​const s8 = iassign(s7, s => s.nested, nested => {    nested.hasChanged = true;    return nested;});​const s9 = iassign(s8, s => s.tags, tags => {    tags.push('new tag');    return tags;});

// nested calls

const s10 = iassign(state, s => {
    s.hasChanged = true;
    
    s.nested = iassign(s.nested, nested => {
        nested.hasChanged = true;
        return nested;
    });
    
    s.tags = iassign(s.tags, tags => {
        tags.push('new tag');
        return tags;
    });
    
    return s;
});

 
const s10 = iassign(state, s => {    s.hasChanged = true;        s.nested = iassign(s.nested, nested => {        nested.hasChanged = true;        return nested;    });        s.tags = iassign(s.tags, tags => {        tags.push('new tag');        return tags;    });        return s;});

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
// sequential calls
// nested calls

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36

Browser/OS: Chrome 63 on Windows

View result in a separate tab

Test name	Executions per second
// sequential calls	243435.1 Ops/sec
// nested calls	687498.9 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 7 months ago):

What is being tested?

The provided benchmark measures the performance of two approaches to assign new values to nested objects in JavaScript:

Sequential calls: In this approach, each assignment operation is performed separately, one after another. This means that for example, s7 is created by assigning a new value to hasChanged, then s8 is created by assigning a new value to nested.hasChanged, and so on.
Nested calls: In this approach, some assignment operations are nested within others. For example, in the first test case, s7 is created by assigning a new value to hasChanged, then immediately creating another object with an iassign function that assigns a new value to nested.hasChanged.

Options being compared

The benchmark compares the performance of these two approaches:

Sequential calls
Nested calls

Pros and Cons of each approach

Sequential calls:
- Pros: Typically easier to understand and maintain, as each assignment operation is separate and self-contained.
- Cons: May be slower due to the overhead of creating and managing multiple object assignments.
Nested calls:
- Pros: Can potentially be faster because only a single object creation is required, and subsequent assignments can reuse the existing object.
- Cons: May be harder to understand and maintain, as nested function calls can make the code more complex.

Library and its purpose

The benchmark uses the iassign library, which provides a simple way to create immutable objects by assigning new values to them. The library is likely used to simplify the assignment operations in the test cases.

Special JS feature or syntax

None mentioned in this explanation.

Other alternatives

There are other ways to achieve similar results without using the iassign library, such as:

Using the Object.assign() method with objects
Creating new objects using the Object.create() method and then assigning values to them
Using libraries like Lodash or Ramda that provide functional programming utilities for working with objects

However, these alternatives may introduce additional complexity and overhead compared to using a dedicated library like iassign.

LLMs can make mistakes. Check important info.

**What is being tested?**

The provided benchmark measures the performance of two approaches to assign new values to nested objects in JavaScript:

1. **Sequential calls**: In this approach, each assignment operation is performed separately, one after another. This means that for example, `s7` is created by assigning a new value to `hasChanged`, then `s8` is created by assigning a new value to `nested.hasChanged`, and so on.
2. **Nested calls**: In this approach, some assignment operations are nested within others. For example, in the first test case, `s7` is created by assigning a new value to `hasChanged`, then immediately creating another object with an `iassign` function that assigns a new value to `nested.hasChanged`.

**Options being compared**

The benchmark compares the performance of these two approaches:

* Sequential calls
* Nested calls

**Pros and Cons of each approach**

* **Sequential calls**:
	+ Pros: Typically easier to understand and maintain, as each assignment operation is separate and self-contained.
	+ Cons: May be slower due to the overhead of creating and managing multiple object assignments.
* **Nested calls**:
	+ Pros: Can potentially be faster because only a single object creation is required, and subsequent assignments can reuse the existing object.
	+ Cons: May be harder to understand and maintain, as nested function calls can make the code more complex.

**Library and its purpose**

The benchmark uses the `iassign` library, which provides a simple way to create immutable objects by assigning new values to them. The library is likely used to simplify the assignment operations in the test cases.

**Special JS feature or syntax**

None mentioned in this explanation.

**Other alternatives**

There are other ways to achieve similar results without using the `iassign` library, such as:

* Using the `Object.assign()` method with objects
* Creating new objects using the `Object.create()` method and then assigning values to them
* Using libraries like Lodash or Ramda that provide functional programming utilities for working with objects

However, these alternatives may introduce additional complexity and overhead compared to using a dedicated library like `iassign`.

Related benchmarks:

iassign sequential vs nested calls (version: 0)

Comparing performance of: // sequential calls vs // nested calls

Created: 7 years ago by: Guest

Jump to the latest result