Benchmark: Remove from array and assign

HTML Preparation code:

<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>
<script type="text/javascript">
    window.lodash = _;
    _ = null;
</script>

Script Preparation code:

var data = [{
    'id': 1,
    'value': 'one'
}, {
    'id': 2,
    'value': 'two'
}, {
    'id': 3,
    'value': 'three'
}, {
    'id': 4,
    'value': 'four'
}, {
    'id': 5,
    'value': 'five'
}];

var removed = [{
    'id': 3,
    'value': 'three'
}, ]

function removedFromData() {
    if (removed.length > 0) {
        removed.forEach((el) => {
            const _index = data.findIndex((ele) => lodash.isEqual(ele, el));
            data.splice(_index, 1);
        });
    }
}

Tests:

lodash
data = lodash.differenceWith(data, removed, lodash.isEqual);
my implementation
removedFromData();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
lodash
my implementation

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36

Browser/OS: Chrome 80 on Linux

View result in a separate tab

Test name	Executions per second
lodash	124779.6 Ops/sec
my implementation	1302098.2 Ops/sec

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

LLMs can make mistakes. Check important info.

I'd be happy to help you understand what's being tested in this JavaScript microbenchmark.

**Benchmark Overview**

The provided benchmark measures the performance of two approaches: using the `lodash.differenceWith` method and implementing a custom solution, "my implementation".

**What is being tested?**

In both test cases:

1.  A sample array `data` is created with five objects.
2.  Another array `removed` is created with one object that should be removed from `data`.
3.  The test case uses the `lodash.isEqual` function to compare objects for equality.

**Options Compared**

Two approaches are compared:

1.  **Using `lodash.differenceWith`**: This method takes three arguments: the array to operate on (`data`), a transform function (`lodash.isEqual`), and another array with elements to remove (`removed`). It returns an array of elements that should be removed from the original array.
2.  **Implementing "my implementation"**: A custom function `removedFromData()` is defined to manually iterate through the `removed` array and find matching objects in `data`. Once a match is found, it uses `splice` to remove the object from `data`.

**Pros and Cons of Each Approach**

1.  **Using `lodash.differenceWith`**:
    *   Pros:
        *   Faster execution time due to optimized implementation.
        *   Less code and easier to maintain.
    *   Cons:
        *   Requires an external library (`lodash`) which might not be available or desirable for all projects.
2.  **Implementing "my implementation"**:
    *   Pros:
        *   No external dependencies required.
        *   Can be more educational for developers to understand the underlying logic.
    *   Cons:
        *   More code and potentially slower execution time due to manual iteration.

**Library: Lodash**

Lodash is a popular JavaScript library that provides a lot of utility functions, including `isEqual`, which is used as the equality test in this benchmark. It's commonly used for simplifying tasks like array manipulation, object comparison, and more.

**Special JS Feature/ Syntax (Not applicable)**

There are no special JavaScript features or syntaxes being tested or used in this benchmark.

**Alternative Approaches**

Other alternatives to implement the same functionality could include:

*   Using `filter()` method with a callback function.
*   Implementing a custom solution using recursion instead of iteration.
*   Utilizing modern JavaScript features like `Array.prototype.filter()` and lambda expressions.

However, these approaches might not be as efficient or maintainable as the current implementation using `lodash.differenceWith` or "my implementation".

Related benchmarks:

Remove from array and assign (version: 0)

Comparing performance of: lodash vs my implementation

Created: 3 years ago by: Guest

Jump to the latest result

lodash

my implementation

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