Benchmark: class with/without declared fields vs function constructor vs object literal vs Object.create vs Object.setPrototypeOf

class with/without declared fields vs function constructor vs object literal vs Object.create vs Object.setPrototypeOf (version: 0) Benchmark.js

Comparing performance of: `class without declared fields vs class with declared fields vs function constructor vs object literal vs object literal & sum.call vs object literal & sum.bind vs Object.create vs Object.setPrototypeOf`

Created: 4 years ago by: Guest

Go to the latest result

Script Preparation code:

// classes declared here can't be accessed in test cases for some reason...

Tests:

class without declared fields
class X { constructor(foo, bar, baz) { this.foo = foo; this.bar = bar; this.baz = baz; } sum() { return this.foo + this.bar + this.baz; } } let i = 1000; let y = 0; while (i--) { let x = new X(1, 2, 3); y += x.foo + x.bar + x.baz; y += x.sum(); } return y;
class with declared fields
class X { foo; bar; baz; constructor(foo, bar, baz) { this.foo = foo; this.bar = bar; this.baz = baz; } sum() { return this.foo + this.bar + this.baz; } } let i = 1000; let y = 0; while (i--) { let x = new X(1, 2, 3); y += x.foo + x.bar + x.baz; y += x.sum(); } return y;
function constructor
function X(foo, bar, baz) { this.foo = foo; this.bar = bar; this.baz = baz; } X.prototype.sum = function() { return this.foo + this.bar + this.baz; } let i = 1000; let y = 0; while (i--) { let x = new X(1, 2, 3); y += x.foo + x.bar + x.baz; y += x.sum(); } return y;
object literal
function X(foo, bar, baz) { return {foo, bar, baz}; } function sum(x) { return x.foo + x.bar + x.baz; } let i = 1000; let y = 0; while (i--) { let x = {foo: 1, bar: 2, baz: 3}; y += x.foo + x.bar + x.baz; y += sum(x); } return y;
object literal & sum.call
function X(foo, bar, baz) { return {foo, bar, baz}; } function sum() { return this.foo + this.bar + this.baz; } let i = 1000; let y = 0; while (i--) { let x = X(1, 2, 3); y += x.foo + x.bar + x.baz; y += sum.call(x); } return y;
object literal & sum.bind
function X(foo, bar, baz) { let x = {foo, bar, baz}; x.sum = sum.bind(x); return x; } function sum() { return this.foo + this.bar + this.baz; } let i = 1000; let y = 0; while (i--) { let x = X(1, 2, 3); y += x.foo + x.bar + x.baz; y += x.sum(); } return y;
Object.create
function X(foo, bar, baz) { let x = Object.create(proto); x.foo = foo; x.bar = bar; x.baz = baz; return x; } const proto = { sum() { return this.foo + this.bar + this.baz; } } let i = 1000; let y = 0; while (i--) { let x = X(1, 2, 3); y += x.foo + x.bar + x.baz; y += x.sum(); } return y;
Object.setPrototypeOf
function X(foo, bar, baz) { let x = {foo, bar, baz}; Object.setPrototypeOf(x, proto); return x; } const proto = { sum() { return this.foo + this.bar + this.baz; } } let i = 1000; let y = 0; while (i--) { let x = X(1, 2, 3); y += x.foo + x.bar + x.baz; y += x.sum(); } return y;

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 runs

object literal

1.6M/s

object literal & sum.call

1.6M/s

object literal & sum.bind

127K/s

class without declared fields

27K/s

function constructor

27K/s

Object.create

10K/s

class with declared fields

5K/s

Object.setPrototypeOf

2K/s

Fastest: object literal (808.0x faster)

View exact numbers

✓ object literal: 1,581,300 ops/sec
• object literal & sum.call: 1,573,507 ops/sec
• object literal & sum.bind: 127,050 ops/sec
• class without declared fields: 26,834 ops/sec
• function constructor: 26,607 ops/sec
• Object.create: 10,024 ops/sec
• class with declared fields: 4,565 ops/sec
• Object.setPrototypeOf: 1,957 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 without declared fields
class with declared fields
function constructor
object literal
object literal & sum.call
object literal & sum.bind
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 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15

Browser/OS: Safari 18 on Mac OS X 10.15.7

View result in a separate tab

object literal & sum.call

1.6M/s

object literal

1.6M/s

object literal & sum.bind

92K/s

class with declared fields

81K/s

function constructor

67K/s

class without declared fields

63K/s

Object.create

47K/s

Object.setPrototypeOf

44K/s

View exact numbers

Test name	Executions per second
✓ object literal & sum.call	1,613,395 Ops/sec
object literal	1,583,286 Ops/sec
object literal & sum.bind	91,517 Ops/sec
class with declared fields	81,251 Ops/sec
function constructor	67,440 Ops/sec
class without declared fields	63,466 Ops/sec
Object.create	47,205 Ops/sec
Object.setPrototypeOf	43,917 Ops/sec

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

LLMs can make mistakes. Check important info.

It looks like we have a benchmarking result for JavaScript performance comparisons!

After analyzing the results, I'll provide some insights:

1. **Chrome 129** is a consistent performer across all tests.
2. The test with the highest **ExecutionsPerSecond** score is **object literal**, which suggests that the test performs better when objects are created using literal syntax (e.g., `let x = { foo: 'bar', bar: 'baz' };`) rather than other methods.
3. The test with the next-highest **ExecutionsPerSecond** score is **object literal & sum.call**, which suggests that combining object creation with the `sum()` function call improves performance.
4. The tests involving **function constructor**, **class without declared fields**, and **class with declared fields** show varying levels of performance, but overall, they are slower than the object literal tests.

These results may be influenced by factors such as:

* JavaScript engine optimizations
* Cache effects on repeated calls to `X(1, 2, 3)`
* The specific use cases and performance requirements of each test

Keep in mind that these findings are based on a single benchmarking result and should be interpreted with caution.

class with/without declared fields vs function constructor vs object literal vs Object.create vs Object.setPrototypeOf (version: 0) Benchmark.js

Comparing performance of: class without declared fields vs class with declared fields vs function constructor vs object literal vs object literal & sum.call vs object literal & sum.bind vs Object.create vs Object.setPrototypeOf

Created: 4 years ago by: Guest

Go to the latest result

class without declared fields

class with declared fields

function constructor

object literal

object literal & sum.call

object literal & sum.bind

Object.create

Object.setPrototypeOf

Historical Performance Data aggregated from 6 community runs

Desktop Results:

Chrome 6 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

Comparing performance of: `class without declared fields vs class with declared fields vs function constructor vs object literal vs object literal & sum.call vs object literal & sum.bind vs Object.create vs Object.setPrototypeOf`