Benchmark: Reflect.deleteProperty vs delete

Script Preparation code:

var many = {}
for (let i = 0; i < 100000; i++) many[i] = i

Tests:

delete - 1 property
var obj = { a: 1 } delete obj.a
Reflect.deleteProperty - 1 property
var obj = { a: 1 } Reflect.deleteProperty(obj, 'a')
delete - * property
delete many[50000] many[50000] = 50000
Reflect.deleteProperty - * property
Reflect.deleteProperty(many, 50000) many[50000] = 50000
delete - 0 property
delete many['x']
Reflect.deleteProperty - 0 property
Reflect.deleteProperty(many, 'x')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
delete - 1 property
Reflect.deleteProperty - 1 property
delete - * property
Reflect.deleteProperty - * property
delete - 0 property
Reflect.deleteProperty - 0 property

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 days ago)

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

Browser/OS: Chrome 135 on Windows

View result in a separate tab

Test name	Executions per second
delete - 1 property	8423314.0 Ops/sec
Reflect.deleteProperty - 1 property	8245476.0 Ops/sec
delete - * property	23063440.0 Ops/sec
Reflect.deleteProperty - * property	22693358.0 Ops/sec
delete - 0 property	36934536.0 Ops/sec
Reflect.deleteProperty - 0 property	33851072.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Overview**

The provided benchmark tests two approaches to delete properties from an object: the built-in `delete` operator and the `Reflect.deleteProperty()` method, introduced in ECMAScript 2015 (ES6). The benchmark consists of four test cases:

1. Deleting a single property (`delete - 1 property`)
2. Deleting a property using `Reflect.deleteProperty()` with a property name as a string (`Reflect.deleteProperty - 1 property`)
3. Deleting a property from an array object (`delete - * property`)
4. Deleting a property from an array object using `Reflect.deleteProperty()` with the index and key as arguments (`Reflect.deleteProperty - * property`)

**Options Compared**

The two options being compared are:

1. **Built-in `delete` operator**: This method uses the browser's internal implementation to delete properties from an object. The behavior of this method is not standardized across all browsers, which can lead to differences in performance.
2. **`Reflect.deleteProperty()` method**: Introduced in ES6, this method provides a standardized way to delete properties from objects. It uses a combination of techniques, including reflection and optimization.

**Pros and Cons**

**Built-in `delete` operator:**

Pros:

* Wide browser support
* Fast execution

Cons:

* Non-standard behavior across browsers
* May not work as expected in certain edge cases (e.g., deleting properties with non-string keys)

**`Reflect.deleteProperty()` method:**

Pros:

* Standardized behavior across browsers
* Optimized for performance

Cons:

* Introduced in ES6, which may affect older browser support
* Requires explicit imports or script tag inclusion

**Other Considerations**

1. **Array property deletion**: The benchmark also tests deleting properties from an array object using both the `delete` operator and `Reflect.deleteProperty()`. This is important to ensure that the optimized implementation can handle array objects correctly.
2. **Edge cases**: The test cases cover various scenarios, such as deleting a single property, a multi-element array property, and a property with a non-string key (using the `delete` operator). These edge cases help identify potential issues with each approach.

**Library and Special JS Features**

There are no libraries mentioned in the provided benchmark. However, it's worth noting that some JavaScript engines, like V8 (used by Chrome), may use additional techniques or optimizations not covered in this benchmark.

No special JavaScript features or syntax are highlighted in this benchmark.

**Alternatives**

For a more comprehensive understanding of array property deletion and object property manipulation, consider exploring other benchmarks or microbenchmarks on MeasureThat.net. Additionally, you can experiment with the following alternatives:

* Using `Object.keys()` and `splice()` to delete properties from an object.
* Implementing your own optimized approach for deleting properties using JavaScript's native `Map` data structure.

Keep in mind that these alternatives might not be directly comparable to the provided benchmark, as they may involve different techniques or assumptions about the input data.

Related benchmarks:

Reflect.deleteProperty vs delete (version: 0)

Comparing performance of: delete - 1 property vs Reflect.deleteProperty - 1 property vs delete - * property vs Reflect.deleteProperty - * property vs delete - 0 property vs Reflect.deleteProperty - 0 property

Created: 4 years ago by: Registered User

Jump to the latest result

delete - 1 property

Reflect.deleteProperty - 1 property

delete - * property

Reflect.deleteProperty - * property

delete - 0 property

Reflect.deleteProperty - 0 property

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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