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;

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

function constructor

1.2M/s

class

1.2M/s

object literal & sum.call

1.1M/s

object literal

1.1M/s

__proto__

33K/s

Object.create

14K/s

Object.setPrototypeOf

9K/s

Fastest: function constructor (134.6x faster)

View exact numbers

✓ function constructor: 1,202,492 ops/sec
• class: 1,191,162 ops/sec
• object literal & sum.call: 1,126,969 ops/sec
• object literal: 1,081,520 ops/sec
• __proto__: 33,421 ops/sec
• Object.create: 13,651 ops/sec
• Object.setPrototypeOf: 8,934 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

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: one year 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

object literal

601K/s

object literal & sum.call

105K/s

function constructor

66K/s

class

65K/s

Object.create

28K/s

__proto__

7K/s

Object.setPrototypeOf

6K/s

View exact numbers

Test name	Executions per second
✓ object literal	600,753 Ops/sec
object literal & sum.call	105,378 Ops/sec
function constructor	65,579 Ops/sec
class	65,264 Ops/sec
Object.create	27,644 Ops/sec
__proto__	6,819 Ops/sec
Object.setPrototypeOf	5,674 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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.

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: 3 years ago by: Guest

Go to the latest result

class

function constructor

object literal

object literal & sum.call

proto

Object.create

Object.setPrototypeOf

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year 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: 3 years ago by: Guest

Go to the latest result

class

function constructor

object literal

object literal & sum.call

__proto__

Object.create

Object.setPrototypeOf

Historical Performance Data aggregated from 5 community runs

Desktop Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

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`

proto