Benchmark: delete vs spread without vs spread override

Script Preparation code:

var query = {
    dates: [],
    latestDate: 'whatever'
};
var query2 = {
    current: {
        query: {
            dates: [1, 2, 3],
            latestDate: 'whatever2'
        }
    }
}

Tests:

delete
let storeQuery = { ...query }; let latestQuery = { ...query2.current?.query }; delete storeQuery.latestDate; delete latestQuery.latestDate;
spread without
const { latestDate: remove, ...storeQuery } = query; const { latestDate: remove1, ...latestQuery } = query2.current?.query || {};
spread override
const storeQuery = { ...query, lastDate: null }; const latestQuery = { ...query2.current?.query, lastDate: null };

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
delete
spread without
spread override

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.

**Benchmark Overview**

The provided JSON represents a JavaScript microbenchmark test case on MeasureThat.net, which compares the performance of three different approaches for deleting a property from an object:

1. **Delete**: Directly using the `delete` operator to delete a property from an object.
2. **Spread without**: Using the spread operator (`...`) to create a new object that excludes the specified property.
3. **Spread override**: Similar to "spread without", but also overrides any inherited properties with the same name.

**Options Comparison**

The three approaches are compared in terms of performance, measured by the number of executions per second (ExecutionsPerSecond).

*   **Pros and Cons:**
    *   **Delete**:
        *   Pros: Simple and straightforward approach.
        *   Cons: May not be as efficient due to the need to update other properties that rely on the deleted property.
    *   **Spread without**:
        *   Pros: Can be more efficient than "delete" because it creates a new object without modifying existing ones. Also, it's a modern JavaScript feature widely supported in browsers and Node.js.
        *   Cons: Requires modern JavaScript versions (ECMAScript 2018+).
    *   **Spread override**:
        *   Pros: Combines the benefits of "spread without" with the ability to override inherited properties.
        *   Cons: Can be less efficient than "delete" for simple property deletion cases, as it creates a new object.

**Library and Special JS Features**

The test case uses the spread operator (`...`), which is a modern JavaScript feature introduced in ECMAScript 2018. The spread operator allows creating a new object by copying all enumerable own properties from an existing object into a new one. This feature is widely supported in browsers and Node.js, making it suitable for performance testing.

**Other Considerations**

In addition to the three approaches, there are other ways to delete a property from an object:

*   **Using bracket notation**: `obj[prop] = undefined;` or `delete obj[prop];`
*   **Using Object.keys() and delete**: `Object.keys(obj).forEach(key => { delete obj[key]; });`

These alternatives may have different performance characteristics compared to the three approaches tested in this benchmark.

**Benchmark Preparation Code Explanation**

The Script Preparation Code section defines two objects: `query` and `query2`. The latter has a nested object property called `current.query`, which is used as the source for creating new properties using the spread operator.

The Html Preparation Code section is empty, indicating that no HTML-related preparation is needed for this benchmark.

Related benchmarks:

delete vs spread without vs spread override (version: 0)

Comparing performance of: delete vs spread without vs spread override

Created: 4 years ago by: Guest

Jump to the latest result

delete

spread without

spread override

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