Benchmark: new empty object vs constant vs frozen constant 2

Script Preparation code:

var empty={};
var frozen=Object.freeze({});
var fnNew=()=>({});
var fnConstant=()=>empty;
var fnFrozen=()=>frozen;

Tests:

new empty
const arr=new Array(500).fill().map(()=>({}));
var
const arr=new Array(500).fill().map(()=>empty);
var frozen
const arr=new Array(500).fill().map(()=>frozen);
fn new
const arr=new Array(500).fill().map(fnNew);
fn var
const arr=new Array(500).fill().map(fnConstant);
fn frozen
const arr=new Array(500).fill().map(fnFrozen);
const
const mty={}; const arr=new Array(500).fill().map(()=>mty);
new2
const dummy={}; const arr=new Array(500).fill().map(()=>({}));

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
new empty
var
var frozen
fn new
fn var
fn frozen
const
new2

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested on MeasureThat.net.

**Benchmark Definition**

The benchmark definition json represents a series of tests designed to compare the performance of different approaches when creating new objects in JavaScript.

Here's a breakdown of the options being compared:

1. **const**: Using the `const` keyword to declare variables that cannot be reassigned.
2. **new empty object**: Creating an empty object using the `new` keyword, followed by `{}`.
3. **constant object**: Assigning an existing object to a variable using the assignment operator (`=`).
4. **frozen constant object**: Freezing an existing object using `Object.freeze()` and then assigning it to a variable.
5. **fn new**: Passing an anonymous function as an argument to the `Array.prototype.fill()` method, which creates a new array with the provided function as its element creator.
6. **fn var**: Assigning a variable containing an empty object to the `Array.prototype.fill()` method's element creator parameter.
7. **fn frozen**: Passing a frozen constant object as an argument to the `Array.prototype.fill()` method.

**Options Comparison**

Each option has its pros and cons:

* **const**:
	+ Pros: Ensures immutability, can be useful for caching or memoization.
	+ Cons: Can lead to slower performance due to type checking and potential reassignment.
* **new empty object**:
	+ Pros: Creates a new object with no existing properties.
	+ Cons: Requires explicit memory allocation, which can be slow.
* **constant object**:
	+ Pros: Efficiently assigns an existing object without creating a new one.
	+ Cons: Does not create a new object; instead, it modifies the original object.
* **frozen constant object**:
	+ Pros: Ensures immutability and prevents accidental modifications.
	+ Cons: Can be slower due to the overhead of freezing an object.
* **fn new**:
	+ Pros: Creates a new array with a custom element creator function.
	+ Cons: Requires defining a separate function, which can add complexity.
* **fn var**:
	+ Pros: Efficiently creates an array without requiring explicit memory allocation.
	+ Cons: May lead to slower performance due to the assignment of a variable containing an object.
* **fn frozen**:
	+ Pros: Ensures immutability and prevents accidental modifications when creating arrays.
	+ Cons: Can be slower due to the overhead of freezing an object.

**Library Usage**

In this benchmark, no specific libraries are used beyond the built-in `Array.prototype.fill()` method and `Object.freeze()`. However, if you're interested in exploring additional libraries for performance optimization or other features, some popular options include:

* Lodash: Provides a range of utility functions, including those for working with arrays and objects.
* Ramda: A functional programming library that offers a set of pre-built functions for manipulating data.

**Conclusion**

The MeasureThat.net benchmark provides a concise way to compare the performance of different approaches when creating new objects in JavaScript. By understanding the pros and cons of each option, you can make informed decisions about which approach to use in your own projects, depending on your specific requirements and constraints.

Latest run results:

Run details: (Test run date: 3 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36

Browser/OS: Chrome 127 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
new empty	459634.9 Ops/sec
var	51248.6 Ops/sec
var frozen	51045.2 Ops/sec
fn new	208625.1 Ops/sec
fn var	46450.2 Ops/sec
fn frozen	46532.0 Ops/sec
const	491199.2 Ops/sec
new2	451122.0 Ops/sec

Related benchmarks:

new empty object vs constant vs frozen constant 2 (version: 0)

Comparing performance of: new empty vs var vs var frozen vs fn new vs fn var vs fn frozen vs const vs new2

Created: 3 months ago by: Guest

Jump to the latest result

new empty

var

var frozen

fn new

fn var

fn frozen

const

new2

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):