Benchmark: indextToRemove & splice vs find vs object key undefined vs object key delete

Tests:

Splice (first item)
const a = [{id: "a"}, {id: "b"}, {id: "c"}, {id: "d"}, {id: "e"}, {id: "f"},{id: "g"},{id: "h"},{id: "i"},{id: "j"},{id: "k"},{id: "l"}]; const indexToRemove = a.findIndex(i => i === "a"); const b = a.splice(indexToRemove, 1);
Splice (last item)
const a = [{id: "a"}, {id: "b"}, {id: "c"}, {id: "d"}, {id: "e"}, {id: "f"},{id: "g"},{id: "h"},{id: "i"},{id: "j"},{id: "k"},{id: "l"}]; const indexToRemove = a.findIndex(i => i === "l"); const b = a.splice(indexToRemove, 1);
Filter (first item)
const a = [{id: "a"}, {id: "b"}, {id: "c"}, {id: "d"}, {id: "e"}, {id: "f"},{id: "g"},{id: "h"},{id: "i"},{id: "j"},{id: "k"},{id: "l"}]; const b = a.filter(item => item.id !== "a")
Filter (last item)
const a = [{id: "a"}, {id: "b"}, {id: "c"}, {id: "d"}, {id: "e"}, {id: "f"},{id: "g"},{id: "h"},{id: "i"},{id: "j"},{id: "k"},{id: "l"}]; const b = a.filter(item => item.id !== "l")
Remove object key (first)
const a = { a: {key: true}, b: {key: true}, c: {key: true}, d: {key: true}, e: {key: true}, f: {key: true}, g: {key: true}, h: {key: true}, i: {key: true}, j: {key: true}, k: {key: true}, l: {key: true} } a.a = undefined
Remove object key (last)
const a = { a: {key: true}, b: {key: true}, c: {key: true}, d: {key: true}, e: {key: true}, f: {key: true}, g: {key: true}, h: {key: true}, i: {key: true}, j: {key: true}, k: {key: true}, l: {key: true} } a.l = undefined
Delete from object
const a = { a: {key: true}, b: {key: true}, c: {key: true}, d: {key: true}, e: {key: true}, f: {key: true}, g: {key: true}, h: {key: true}, i: {key: true}, j: {key: true}, k: {key: true}, l: {key: true} } delete a.l

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Splice (first item)
Splice (last item)
Filter (first item)
Filter (last item)
Remove object key (first)
Remove object key (last)
Delete from object

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.

Let's break down what is being tested in the provided benchmark.

**What is being tested?**

The benchmark tests four different operations:

1. **Delete from object**: Removing a property from an object using the `delete` keyword.
2. **Remove object key (first)**: Removing the first property from an object using bracket notation (`obj[key] = undefined; delete obj[key];`).
3. **Remove object key (last)**: Removing the last property from an object using bracket notation (`obj[key] = undefined; delete obj[key - 1];`).
4. **Filter (first/last item)**: Filtering out the first or last item from an array.

**Test methods**

Each test method uses a simple implementation:

* Delete from object: `const obj = {a: 1, b: 2}; delete obj.b;`
* Remove object key (first/last): `const obj = {a: 1, b: 2}; obj[0] = undefined; delete obj[0];` or `obj[obj.length - 1] = undefined; delete obj[obj.length - 1];`
* Filter (first/last item): `const arr = [1, 2, 3]; const filteredArr = arr.filter((item) => item !== 2);`

**Benchmark results**

The benchmark results show the number of executions per second for each test method on a desktop Windows machine running Chrome 88.

**Interpretation**

The results suggest that:

* Delete from object is the fastest operation, with an average of around 6700-7000 executions per second.
* Remove object key (last) and filter (first item) are relatively slow, with averages around 4000-6000 executions per second.
* Remove object key (first) falls in between, with an average of around 5000-6000 executions per second.

**Implications**

These results may have implications for developers who need to perform these operations frequently. For example:

* Consider using `delete` keyword instead of bracket notation or filter methods when possible.
* Be aware that removing properties from objects can lead to memory fragmentation, which may impact performance in certain scenarios.
* Filter methods can be useful when working with large datasets, but they may incur a higher overhead than simple loop-based approaches.

Keep in mind that these results are specific to Chrome 88 on desktop Windows machines and may not generalize to other browsers, operating systems, or use cases.

Related benchmarks:

indextToRemove & splice vs find vs object key undefined vs object key delete (version: 0)

Comparing performance of: Splice (first item) vs Splice (last item) vs Filter (first item) vs Filter (last item) vs Remove object key (first) vs Remove object key (last) vs Delete from object

Created: 5 years ago by: Guest

Jump to the latest result

Splice (first item)

Splice (last item)

Filter (first item)

Filter (last item)

Remove object key (first)

Remove object key (last)

Delete from object

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