Benchmark: Empty an object in JavaScript (with baseline)

Script Preparation code:

var size = 100000;
var o = {};
for (var i = 0; i < size; i++) {
  o[`prop${i}`] = Math.random();
}
var json = JSON.stringify(o);

Tests:

Instantiate new object
var o1 = JSON.parse(json); o1 = {};
Delete all properties
var o2 = JSON.parse(json); Object.keys(o2).forEach(k => delete o2[k]);
JSON.parse baseline
var o0 = JSON.parse(json);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Instantiate new object
Delete all properties
JSON.parse baseline

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark definition and test cases.

**Benchmark Definition**

The benchmark measures how fast an object with 100,000 properties can be emptied in JavaScript. The object is created using a loop that generates random values for each property. There are three ways to empty the object:

1. Instantiating a new object (`Instantiate new object`): `var o1 = JSON.parse(json); o1 = {};`
2. Deleting all properties (`Delete all properties`): `var o2 = JSON.parse(json); Object.keys(o2).forEach(k => delete o2[k]);`
3. Using the `JSON.parse` method with a baseline (`JSON.parse baseline`): `var o0 = JSON.parse(json);`

**Options Comparison**

The three options are compared to measure their performance. Here's a brief overview of each approach:

1. **Instantiate new object**: Creating a new object using `new Object()` and assigning it the result of `JSON.parse(json)`. This method creates a new object and then immediately replaces it with an empty object.
2. **Delete all properties**: Using `Object.keys()` to get an array of property names, then iterating over that array and deleting each property using `delete`.
3. **JSON.parse baseline**: Simply parsing the JSON string using `JSON.parse(json)` and storing the result in a variable.

**Pros and Cons**

1. **Instantiate new object**:
	* Pros: Creates a new object and immediately replaces it with an empty one, which might be faster since it avoids unnecessary property lookup.
	* Cons: Requires creating a new object, which can be slower for large objects due to memory allocation.
2. **Delete all properties**:
	* Pros: Avoids creating a new object, which can be beneficial for performance-critical code.
	* Cons: Requires iterating over an array of property names, which can be slower than simply replacing the object with an empty one.
3. **JSON.parse baseline**:
	* Pros: Does not create any additional objects or arrays, making it a simple and lightweight approach.
	* Cons: May be slower since `JSON.parse` needs to parse the entire JSON string, which includes property names.

**Library Usage**

None of the test cases explicitly use any libraries. However, the benchmark definition uses the `JSON` library, which is a built-in JavaScript library that provides methods for working with JSON data.

**Special JS Features or Syntax**

The only special feature used in this benchmark is `JSON.parse`, which is a method provided by the `JSON` library. This method parses a JSON string into a JavaScript object.

**Alternatives**

Other alternatives to measure how fast an object can be emptied might include:

* Using a different data structure, such as an array or a Map, instead of an object.
* Adding more properties to the object before emptying it.
* Using a caching mechanism to store the result of `JSON.parse(json)` and reusing it instead of parsing the JSON string every time.
* Measuring the performance of a custom implementation for emptying objects, such as using a specialized data structure or algorithm.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36

Browser/OS: Chrome 118 on Windows

View result in a separate tab

Test name	Executions per second
Instantiate new object	35.5 Ops/sec
Delete all properties	21.2 Ops/sec
JSON.parse baseline	34.3 Ops/sec

Related benchmarks:

Empty an object in JavaScript (with baseline) (version: 0)

Given an object with 100,000 properties with random values, is it faster to empty the object by instantiating a new object or by deleting all properties?

Comparing performance of: Instantiate new object vs Delete all properties vs JSON.parse baseline

Created: one year ago by: Guest

Jump to the latest result

Instantiate new object

Delete all properties

JSON.parse baseline

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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