Benchmark: Object.assign vs defineProperties vs setPrototypeOf vs extends Function vs defineProperty

Tests:

Object.assign
let f = ()=>0 Object.assign(f, { _foo: null, get foo() {return this._foo}, set foo(_foo) {this._foo = _foo}, })
defineProperties
let f = ()=>0 Object.defineProperties(f, { foo: { value: null, writable: true } })
setPrototypeOf
let f = ()=>0 Object.setPrototypeOf(f, { ...Function.prototype, _foo: null, get foo() {return this._foo}, set foo(_foo) {this._foo = _foo}, })
extends Function
class F extends Function { constructor() { super('return 0') } _foo = null get foo() {return this._foo} set foo(_foo) {this._foo = _foo} }
defineProperty
let f = ()=>0 f._foo = null Object.defineProperty(f, 'foo', { get() { return this._foo }, set(_foo) { this._foo = _foo } })

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Object.assign
defineProperties
setPrototypeOf
extends Function
defineProperty

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

**Overview**

The provided benchmark compares the performance of four different approaches to set properties on an object:

1. `Object.assign`
2. `defineProperties`
3. `setPrototypeOf` (combined with object property definition)
4. `extends Function` (using a class-based approach)

These approaches aim to achieve similar results, but with varying levels of overhead and complexity.

**Approach 1: Object.assign**

`Object.assign` is a method that copies properties from one or more source objects to a target object. In this benchmark, it's used to set properties on an object by assigning the new values to the existing object.

Pros:

* Simple and concise syntax
* Fast execution

Cons:

* May not work correctly with inherited properties
* Can be slower due to unnecessary property assignments

**Approach 2: defineProperties**

`defineProperties` is a method that allows defining properties on an object at creation time. In this benchmark, it's used to set properties by defining the property descriptor.

Pros:

* Flexible and customizable property definitions
* Fast execution for simple cases

Cons:

* Can be slower for complex property definitions
* May require more memory due to internal data structures

**Approach 3: setPrototypeOf**

`setPrototypeOf` is a method that sets the prototype of an object. In this benchmark, it's used in combination with `Object.defineProperty` to set properties on an object.

Pros:

* Efficient use of memory and CPU resources
* Works correctly with inherited properties

Cons:

* Can be slower for large objects due to recursive property lookup
* Requires careful configuration to achieve optimal performance

**Approach 4: extends Function**

The `extends Function` approach uses a class-based approach to define the object. The `F` class is defined as an extension of the `Function` class, and properties are set using instance methods.

Pros:

* Can be faster for large objects due to method call optimization
* Works correctly with inherited properties

Cons:

* Requires more memory due to the creation of a new class
* More complex syntax and setup required

**Other Considerations**

* Memory usage: `setPrototypeOf` and `extends Function` approaches may require more memory due to internal data structures.
* CPU resources: All approaches can be affected by CPU resources, especially for large objects or complex property definitions.
* Browser support: Firefox 128 is the target browser in this benchmark. Other browsers might have different behavior or support for these methods.

**Alternative Approaches**

Other alternatives could include:

* Using a library like Lodash or Underscore.js to provide a unified API for property manipulation
* Implementing a custom property setter using WebAssembly (WASM) or other performance-oriented languages
* Using a more modern approach, such as using the `Object` prototype's `setPrototypeOf` method directly.

Keep in mind that this is just an overview of the different approaches. The actual implementation and choice of approach depend on specific requirements and constraints.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.1 Safari/605.1.15

Browser/OS: Safari 18 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Object.assign	5756590.5 Ops/sec
defineProperties	8628433.0 Ops/sec
setPrototypeOf	2514275.0 Ops/sec
extends Function	6568385.5 Ops/sec
defineProperty	9190647.0 Ops/sec

Related benchmarks:

Object.assign vs defineProperties vs setPrototypeOf vs extends Function vs defineProperty (version: 2)

Comparing performance of: Object.assign vs defineProperties vs setPrototypeOf vs extends Function vs defineProperty

Created: one year ago by: Registered User

Jump to the latest result

Object.assign

defineProperties

setPrototypeOf

extends Function

defineProperty

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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