Benchmark: Class property - delete vs undefined

Tests:

delete
class test { prop = 'test'; clear() { delete this.prop; } } new test().clear();
undefined
class test { prop = 'test'; clear() { this.prop = undefined; } } new test().clear();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
delete
undefined

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/92.0.4515.131 Safari/537.36

Browser/OS: Chrome 92 on Linux

View result in a separate tab

Test name	Executions per second
delete	153294.2 Ops/sec
undefined	147471.3 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**What is being tested?**

The benchmark is testing two different approaches to clearing a class property in JavaScript:

1. `delete this.prop;`
2. `this.prop = undefined;`

In other words, the benchmark is measuring the performance difference between deleting a property directly using the `delete` keyword and assigning it to `undefined`.

**Options compared**

There are two options being compared:

1. **Delete (`delete this.prop;`)**
	* Pros:
		+ Directly deletes the property, which might be more intuitive for some developers.
	* Cons:
		+ Might not work in all situations (e.g., when using `Object.defineProperty` or `Object.freeze`).
2. **Assign to `undefined` (`this.prop = undefined;`)**
	* Pros:
		+ Works in most cases, including those mentioned above.
	* Cons:
		+ Might be less intuitive than deleting the property directly.

**Pros and cons of each approach**

1. **Delete (`delete this.prop;`)**:
	* Pros: More straightforward, potentially faster.
	* Cons: Might not work everywhere (e.g., with `Object.defineProperty` or `Object.freeze`).
2. **Assign to `undefined` (`this.prop = undefined;`)**:
	* Pros: Works in most cases, more reliable than deleting the property directly.
	* Cons: Might be less intuitive, potentially slower.

**Library usage**

There is no library being used in this benchmark. The code is pure JavaScript.

**Special JS feature or syntax**

None of the test cases use any special JavaScript features or syntax beyond standard JavaScript syntax.

**Other alternatives**

If you wanted to compare other approaches to clearing a class property, some alternatives could be:

1. `this[prop] = undefined;`
2. Using `Object.defineProperty` with `deleteProp: true`
3. Using `Reflect.deleteProperty`

These alternatives would require modifications to the benchmark code and might introduce additional factors that affect performance.

Keep in mind that the choice of approach ultimately depends on the specific use case and requirements of your project.

As a side note, it's worth noting that the `delete` keyword is optimized in modern JavaScript engines (e.g., V8 in Chrome) to perform more efficiently than assigning to `undefined`. This optimization might affect the benchmark results.

Related benchmarks:

Class property - delete vs undefined (version: 0)

Comparing performance of: delete vs undefined

Created: 3 years ago by: Guest

Jump to the latest result

delete

undefined

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