Benchmark: Object.create mutation vs Object.create mutation descriptors vs setPrototypeOf rm

Script Preparation code:

for (i = 0; i < 10; i++) {}

Tests:

Object.create mutation
const proto = { m1() { return 4324 }, m2() { return "park"} }; const obj = Object.create(proto) obj.age = 65 obj.name = "john"
Object.create mutation descriptors
const proto = { m1() { return 4324 }, m2() { return "park"} }; const obj = Object.create(proto, Object.getOwnPropertyDescriptors({age: 65, name: "john"}));
setPrototypeOf
const proto = { m1() { return 4324 }, m2() { return "park"} }; const obj = {age: 65, name: "john"} Object.setPrototypeOf(obj, proto);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.create mutation
Object.create mutation descriptors
setPrototypeOf

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of three approaches for creating and mutating objects in JavaScript:

1. `Object.create`
2. `Object.create` with descriptor objects
3. Setting prototype using `Object.setPrototypeOf`

These approaches differ in how they define the object's prototype, which affects their behavior when it comes to inheritance, property creation, and mutation.

**Approach 1: `Object.create`**

This approach creates a new object that inherits from the provided prototype. The `Object.create` method takes two arguments: the prototype and an optional options object. If no options object is provided, as in this case, it uses the default inheritance behavior.

In this benchmark, the test creates an object with properties `age` and `name`, and then assigns values to these properties.

**Pros and Cons**

* Pros:
	+ Simple and concise syntax.
	+ Fast execution performance.
* Cons:
	+ Inflexible: does not allow for customization of inheritance behavior.
	+ May lead to unexpected behavior if not used carefully (e.g., when working with prototypes that are already set).

**Approach 2: `Object.create` with descriptor objects**

This approach uses the `Object.getOwnPropertyDescriptors` method to define the properties of the object. This allows for more fine-grained control over inheritance and property creation.

In this benchmark, the test creates an object with properties `age` and `name`, and then assigns values to these properties using the `Object.create` method with a descriptor object.

**Pros and Cons**

* Pros:
	+ Allows for customization of inheritance behavior.
	+ More flexible than the simple `Object.create` approach.
* Cons:
	+ Slightly slower execution performance compared to the simple `Object.create` approach.
	+ Requires additional setup (creating the descriptor object).

**Approach 3: Setting prototype using `Object.setPrototypeOf`**

This approach sets the prototype of an existing object using the `Object.setPrototypeOf` method. This allows for more control over inheritance and property creation.

In this benchmark, the test creates an object with properties `age` and `name`, and then sets its prototype to a predefined object.

**Pros and Cons**

* Pros:
	+ Fast execution performance.
	+ Allows for customization of inheritance behavior.
* Cons:
	+ May lead to unexpected behavior if not used carefully (e.g., when working with objects that have already been mutated).
	+ Requires setting the prototype explicitly, which can be error-prone.

**Library/Functionality Descriptions**

* `Object.create`: Creates a new object that inherits from the provided prototype. If no options object is provided, it uses the default inheritance behavior.
* `Object.getOwnPropertyDescriptors`: Returns an object containing the property descriptors of the given object or prototype. This method is used to define properties in the `Object.create` approach with descriptor objects.
* `Object.setPrototypeOf`: Sets the prototype of an existing object.

**Special JS Features/Syntax**

The benchmark uses JavaScript features and syntax that are commonly used in modern web development, such as:

* ES6 class-like syntax for defining functions (e.g., `m1() { return 4324 }`)
* Object literals (e.g., `{ age: 65, name: "john" }`)
* The `Object.create` method
* The `Object.prototype` and `Object.prototype.hasOwnProperty` methods

**Other Alternatives**

If you're looking for alternative approaches to creating and mutating objects in JavaScript, consider the following:

* Using a library like Lodash or Ramda, which provides utility functions for working with objects, including creation and mutation.
* Using a framework like React or Angular, which provide built-in mechanisms for managing state and behavior.
* Using a different programming paradigm, such as functional programming or object-oriented programming.

Latest run results:

Run details: (Test run date: one year ago)

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

Browser/OS: Chrome 115 on Windows

View result in a separate tab

Test name	Executions per second
Object.create mutation	163958.1 Ops/sec
Object.create mutation descriptors	125076.1 Ops/sec
setPrototypeOf	181181.0 Ops/sec

Related benchmarks:

Object.create mutation vs Object.create mutation descriptors vs setPrototypeOf rm (version: 0)

Comparing performance of: Object.create mutation vs Object.create mutation descriptors vs setPrototypeOf

Created: one year ago by: Registered User

Jump to the latest result

Object.create mutation

Object.create mutation descriptors

setPrototypeOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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