Benchmark: Object.create() vs literal destructure

Script Preparation code:

var emptyPair = {
  pair: '',
  svc: '',
  rate: 0,
  rateId: '',
  limit: 0,
  min: 0,
  minerFee: 0,
  unavailable: true,
  details: '',
  maxLimit: 0,
  chainPair: '',
}

var emptyPairNullProto = Object.create(null)
emptyPairNullProto.pair = ''
emptyPairNullProto.svc = ''
emptyPairNullProto.rate = 0
emptyPairNullProto.rateId = ''
emptyPairNullProto.limit = 0
emptyPairNullProto.min = 0
emptyPairNullProto.minerFee = 0
emptyPairNullProto.unavailable = true
emptyPairNullProto.details = ''
emptyPairNullProto.maxLimit = 0
emptyPairNullProto.chainPair = ''

Tests:

Object.create()
const a = Object.create(emptyPair, { details: { value: 'new details'}, pair: {value: 'from_to'} })
Destructure
const b = { ...emptyPair, details: 'new details', pair: 'from_to', }
Object.create() null proto
const c = Object.create(emptyPairNullProto, { details: { value: 'new details'}, pair: {value: 'from_to'} })
Destructure null proto
const d = { ...emptyPairNullProto, details: 'new details', pair: 'from_to', }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.create()
Destructure
Object.create() null proto
Destructure null proto

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

Browser/OS: Chrome 95 on Linux

View result in a separate tab

Test name	Executions per second
Object.create()	1105108.5 Ops/sec
Destructure	397677.0 Ops/sec
Object.create() null proto	1179677.8 Ops/sec
Destructure null proto	347615.0 Ops/sec

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

LLMs can make mistakes. Check important info.

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

**Benchmark Definition**

The benchmark measures the performance difference between two approaches: using `Object.create()` with an object as its prototype, and literal destructuring to create objects.

**Options compared**

There are four test cases:

1. **`Object.create()` with an object as its prototype**: This approach uses the `Object.create()` method to create a new object that inherits properties from a given object (`emptyPairNullProto`). The second argument to `Object.create()` is an object that defines the properties to be inherited by the new object.
2. **Literal destructuring**: This approach uses the syntax `{...obj, prop: value}` to create a new object with the same properties as `obj`, but with additional properties (`details` and `pair`) added manually.

**Pros and Cons of each approach**

1. **`Object.create()`**:
	* Pros:
		+ More explicit and readable way to define inherited properties.
		+ Can be more efficient when working with complex object hierarchies.
	* Cons:
		+ May require more boilerplate code, which can increase execution time.
		+ Not as concise or elegant as literal destructuring.
2. **Literal destructuring**:
	* Pros:
		+ More concise and expressive syntax.
		+ Can be faster due to reduced overhead of method calls and object creation.
	* Cons:
		+ May be less readable for developers unfamiliar with this syntax.
		+ Can lead to confusion when working with complex object hierarchies.

**Library usage**

There is no explicit library mentioned in the benchmark definition. However, `Object.create()` is a built-in JavaScript method, while literal destructuring is a shorthand syntax that relies on implicit conversions between objects and property assignments.

**Special JS features or syntax**

The benchmark uses the following special feature:

1. **Spread operator (`{...}`)**: This operator allows you to create a new object by copying properties from an existing object (in this case, `emptyPairNullProto`). The spread operator is a shorthand for creating a new object with the same properties as the original object, plus additional properties.

**Other alternatives**

For comparison, other approaches could include:

1. **Function constructor**: Creating objects using the function constructor syntax (`new Func()`).
2. **Class declaration**: Using class declarations to create objects.
3. **Other libraries or frameworks**: Depending on the specific use case, alternative libraries or frameworks might be used to achieve similar results.

Keep in mind that the benchmark's focus is on comparing the performance of `Object.create()` with literal destructuring, so other alternatives are not necessarily relevant to this specific comparison.

Related benchmarks:

Object.create() vs literal destructure (version: 2)

Comparing performance of: Object.create() vs Destructure vs Object.create() null proto vs Destructure null proto

Created: 3 years ago by: Registered User

Jump to the latest result

Object.create()

Destructure

Object.create() null proto

Destructure null proto

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