Benchmark: destructuring X undefined X null X delete X new ref X reflect x reflect spread - MeasureThat.net

Tests:

Destruct
const user = { email: '123@email.com', password: 'AA&Â&A*&AA' }; const {password, ...toBeReturned} = user;
Undefined
const user = { email: '123@email.com', password: 'AA&Â&A*&AA' }; user.password = undefined;
Null
const user = { email: '123@email.com', password: 'AA&Â&A*&AA' }; user.password = null;
Delete
const user = { email: '123@email.com', password: 'AA&Â&A*&AA' }; delete user.password;
New Ref
const user = { email: '123@email.com', password: 'AA&Â&A*&AA' }; const toBeReturned = {email: user.email};
Reflect
const user = { email: '123@email.com', password: 'AA&Â&A*&AA' }; Reflect.deleteProperty(user, 'password')
Reflect Spread
const user = { email: '123@email.com', password: 'AA&Â&A*&AA' }; Reflect.deleteProperty({...user}, 'password')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Destruct
Undefined
Null
Delete
New Ref
Reflect
Reflect Spread

Fastest: N/A

Slowest: N/A

Autogenerated LLM Sumamry (model llama3.2:3b, generated 11 days ago):

LLMs can make mistakes. Check important info.

The provided JSON represents a set of JavaScript microbenchmarks for measuring the performance of various destructuring techniques.

**Destructuring Techniques:**

1. **Destruct**: This test case compares the execution time of two approaches:
	* `const {password, ...toBeReturned} = user;` - This approach uses the "destruct" syntax to extract a subset of properties from an object.
	* `const destructedUser = user; destructedUser.password = undefined; const {password: passwordValue} = destructedUser;` - This approach uses a more verbose syntax to achieve the same result.

Pros of the first approach:
	+ More concise and readable
	+ Fewer lines of code

Cons of the first approach:
	+ May not be as efficient, since it requires creating a new object

2. **Undefined**: This test case compares the execution time of two approaches:
	* `user.password = undefined;` - This approach directly sets the property to `undefined`.
	* `const user = {email: '123@email.com', password: 'AA&Â&A*&AA'}; user.password = null;` - This approach creates a new object with the updated value.

Pros of the first approach:
	+ Fewer lines of code
	+ Directly sets the property to `undefined`

Cons of the first approach:
	+ May not be as efficient, since it requires creating a new object

3. **Null**: Similar to the "Undefined" test case, this test compares two approaches:
	* `user.password = null;` - This approach directly sets the property to `null`.
	* `const user = {email: '123@email.com', password: 'AA&Â&A*&AA'}; const updatedUser = {...user}; updatedUser.password = null;`

Pros of the first approach:
	+ Fewer lines of code
	+ Directly sets the property to `null`

Cons of the first approach:
	+ May not be as efficient, since it requires creating a new object

4. **Delete**: This test case compares two approaches:
	* `delete user.password;` - This approach uses the "delete" operator to remove the property.
	* `const user = {email: '123@email.com', password: 'AA&Â&A*&AA'}; delete user.password;`

Pros of the first approach:
	+ More concise and readable
	+ Fewer lines of code

Cons of the first approach:
	+ May not be as efficient, since it requires creating a new object

5. **New Ref**: This test case compares two approaches:
	* `const toBeReturned = {email: user.email};` - This approach creates a new object with a subset of properties.
	* `const user = {email: '123@email.com', password: 'AA&Â&A*&AA'}; const updatedUser = {...user}; updatedUser.password = undefined; const {password: passwordValue} = updatedUser;`

Pros of the first approach:
	+ More concise and readable
	+ Fewer lines of code

Cons of the first approach:
	+ May not be as efficient, since it requires creating a new object

6. **Reflect**: This test case compares two approaches:
	* `Object.prototype.hasOwnProperty.call(user, 'password');` - This approach uses the "hasOwnProperty" method to check if the property exists.
	* `const user = {email: '123@email.com', password: 'AA&Â&A*&AA'}; const hasPassword = Object.hasOwn(user, 'password');`

Pros of the first approach:
	+ More concise and readable
	+ Fewer lines of code

Cons of the first approach:
	+ May not be as efficient, since it requires calling a method on the object prototype.

7. **Destruct Spread**: This test case compares two approaches:
	* `const destructedUser = {...user}; destructedUser.password = undefined; const {password: passwordValue} = destructedUser;` - This approach uses the spread operator to create a new object and then updates it.
	* `const user = {email: '123@email.com', password: 'AA&Â&A*&AA'}; const updatedUser = {...user}; updatedUser.password = undefined; const {password: passwordValue} = updatedUser;`

Pros of the first approach:
	+ More concise and readable
	+ Fewer lines of code

Cons of the first approach:
	+ May not be as efficient, since it requires creating a new object

Overall, the tests suggest that the most efficient approaches are those that use direct property access or the "delete" operator. However, the results may vary depending on the specific use case and implementation.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36

Browser/OS: Chrome 83 on Mac OS X 10.14.6

View result in a separate tab

Test name	Executions per second
Destruct	3302485.0 Ops/sec
Undefined	7621006.0 Ops/sec
Null	940147600.0 Ops/sec
Delete	24596150.0 Ops/sec
New Ref	938518000.0 Ops/sec
Reflect	5260388.0 Ops/sec
Reflect Spread	2245974.0 Ops/sec

Related benchmarks: