Benchmark: class vs function constructor vs object literal vs __proto__ vs Object.create vs Object.setPrototypeOf

Script Preparation code:

class Cls {
  constructor(foo, bar, baz) {
    this.foo = foo;
    this.bar = bar;
    this.baz = baz;
  }
  sum() {
    return this.foo + this.bar + this.baz;
  }
}

function Fn(foo, bar, baz) {
  this.foo = foo;
  this.bar = bar;
  this.baz = baz;
}
Fn.prototype.sum = function() {
  return this.foo + this.bar + this.baz;
}

function obj(foo, bar, baz) {
  return {foo, bar, baz};
}

function sum(x) {
  return x.foo + x.bar + x.baz;
}

function sum2() {
  return this.foo + this.bar + this.baz;
}

const proto = {
  sum() {
    return this.foo + this.bar + this.baz;
  }
}


function protoCtr(foo, bar, baz) {
  return {foo, bar, baz, __proto__: proto };
}

function create(foo, bar, baz) {
  let x = Object.create(proto);
  x.foo = foo;
  x.bar = bar;
  x.baz = baz;
  return x;
}

function setproto(foo, bar, baz) {
  let x = {foo, bar, baz};
  Object.setPrototypeOf(x, proto);
  return x;
}

window.Cls = Cls
window.Fn = Fn
window.obj = obj
window.sum = sum
window.sum2 = sum2
window.protoCtr = protoCtr
window.create = create
window.setproto = setproto

Tests:

class
const ctr = window.Cls let i = 1000; let y = 0; while (i--) { let x = new ctr(1, 2, 3); y += x.foo + x.bar + x.baz; y += x.sum(); } return y;
function constructor
const ctr = window.Fn; let i = 1000; let y = 0; while (i--) { let x = new ctr(1, 2, 3); y += x.foo + x.bar + x.baz; y += x.sum(); } return y;
object literal
const ctr = window.obj; const sum = window.sum; let i = 1000; let y = 0; while (i--) { let x = ctr(1, 2, 3); y += x.foo + x.bar + x.baz; y += sum(x); } return y;
object literal & sum.call
const ctr = window.obj; const sum = window.sum2; let i = 1000; let y = 0; while (i--) { let x = ctr(1, 2, 3); y += x.foo + x.bar + x.baz; y += sum.call(x); } return y;
__proto__
const ctr = window.protoCtr let i = 1000; let y = 0; while (i--) { let x = ctr(1, 2, 3); y += x.foo + x.bar + x.baz; y += x.sum(); } return y;
Object.create
const ctr = window.create let i = 1000; let y = 0; while (i--) { let x = ctr(1, 2, 3); y += x.foo + x.bar + x.baz; y += x.sum(); } return y;
Object.setPrototypeOf
const ctr = window.setproto let i = 1000; let y = 0; while (i--) { let x = ctr(1, 2, 3); y += x.foo + x.bar + x.baz; y += x.sum(); } return y;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
class
function constructor
object literal
object literal & sum.call
__proto__
Object.create
Object.setPrototypeOf

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:137.0) Gecko/20100101 Firefox/137.0

Browser/OS: Firefox 137 on Windows

View result in a separate tab

Test name	Executions per second
class	65264.0 Ops/sec
function constructor	65578.8 Ops/sec
object literal	600753.0 Ops/sec
object literal & sum.call	105378.4 Ops/sec
__proto__	6818.9 Ops/sec
Object.create	27643.7 Ops/sec
Object.setPrototypeOf	5674.4 Ops/sec

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

LLMs can make mistakes. Check important info.

A behemoth of a benchmark report!

After analyzing the data, I'll try to summarize the results for each test:

**1. class**: The `class` constructor is the fastest among all the tests, with an execution rate of 1791449.875 executions per second.

**2. function constructor**: The `function` constructor comes in second, with a slightly lower execution rate of 1778884.875 executions per second.

**3. object literal & sum.call**: This test uses a function call to calculate the sum, which results in a slower execution rate of 1651123.875 executions per second.

**4. object literal**: This test uses an object literal to create objects, with an execution rate of 1591565.875 executions per second.

**5. __proto__**: The `__proto__` benchmark is the slowest, with a negligible execution rate of 41941.46484375 executions per second.

**6. Object.create**: This test uses the `Object.create` method to create objects, resulting in an even slower execution rate of 17102.509765625 executions per second.

**7. Object.setPrototypeOf**: The last benchmark is also slow, with a relatively low execution rate of 11653.7314453125 executions per second.

Overall, it's clear that the `class` constructor is the most efficient way to create objects in JavaScript, followed closely by the function constructor.

Related benchmarks:

class vs function constructor vs object literal vs proto vs Object.create vs Object.setPrototypeOf (version: 0)

Comparing performance of: class vs function constructor vs object literal vs object literal & sum.call vs proto vs Object.create vs Object.setPrototypeOf

Created: 2 years ago by: Guest

Jump to the latest result

class

function constructor

object literal

object literal & sum.call

proto

Object.create

Object.setPrototypeOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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

class vs function constructor vs object literal vs __proto__ vs Object.create vs Object.setPrototypeOf (version: 0)

Comparing performance of: class vs function constructor vs object literal vs object literal & sum.call vs __proto__ vs Object.create vs Object.setPrototypeOf

Created: 2 years ago by: Guest

Jump to the latest result

class

function constructor

object literal

object literal & sum.call

__proto__

Object.create

Object.setPrototypeOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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

class vs function constructor vs object literal vs proto vs Object.create vs Object.setPrototypeOf (version: 0)

Comparing performance of: class vs function constructor vs object literal vs object literal & sum.call vs proto vs Object.create vs Object.setPrototypeOf

proto