Benchmark: New Objects - MeasureThat.net

Tests:

Create 100000 Objects with same service
class AuthUser {} class UserService { constructor(authUser) { this.authUser = authUser; } getUserById(id) { return id; } } const userService = new UserService(new AuthUser()); for (i = 0; i < 100000; i++) { userService.authUser = new AuthUser(); }
Create 100000 Objects
class AuthUser {} class UserService { constructor(authUser) { this.authUser = authUser; } getUserById(id) { return id; } } for (i = 0; i < 100000; i++) { new UserService(new AuthUser()); }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Create 100000 Objects with same service
Create 100000 Objects

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) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36

Browser/OS: Chrome 117 on Windows

View result in a separate tab

Test name	Executions per second
Create 100000 Objects with same service	605.0 Ops/sec
Create 100000 Objects	382.4 Ops/sec

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

LLMs can make mistakes. Check important info.

**Benchmark Overview**

The provided benchmark measures the performance of creating new objects in JavaScript, specifically focusing on two different scenarios:

1. Creating 100,000 objects with the same service instance (`"Create 100000 Objects with same service"`).
2. Creating 100,000 individual object instances (`"Create 100000 Objects"`).

**Script Preparation Code**

The script preparation code for both benchmark definitions is identical:
```javascript
class AuthUser {}
class UserService {
    constructor(authUser) {
        this.authUser = authUser;
    }
    getUserById(id) {
        return id;
    }
}
const userService = new UserService(new AuthUser());
for (i = 0; i < 100000; i++) {
    // Either create a new instance with the same service or just reuse the existing one
    if (/* scenario */) {
        userService.authUser = new AuthUser();
    }
}
```
**Options Compared**

The two benchmark definitions compare the performance of:

1. **Reuse the existing `userService` instance**: In this case, a new `AuthUser` object is assigned to the `authUser` property of the existing `userService` instance.
2. **Create a new individual `UserService` instance for each iteration**: A new `UserService` instance is created with a new `AuthUser` object in each iteration.

**Pros and Cons**

### Reuse the existing `userService` instance:

Pros:

* Reduces memory allocation overhead, as only one `AuthUser` object needs to be created.
* May exhibit better performance due to reduced garbage collection.

Cons:

* Increases the complexity of the code, as it relies on the shared state of the `userService` instance.
* May lead to unexpected behavior if not handled correctly.

### Create a new individual `UserService` instance for each iteration:

Pros:

* Simplifies the code, as each iteration is independent and doesn't rely on shared state.
* Easier to reason about, as the performance characteristics are more predictable.

Cons:

* Increases memory allocation overhead, as 100,000 `AuthUser` objects need to be created.
* May exhibit worse performance due to increased garbage collection.

**Library Usage**

The benchmark uses the `class` keyword and object literals to define the `AuthUser` and `UserService` classes. The `class` keyword is a JavaScript feature introduced in ECMAScript 2015 (ES6).

No external libraries are used in this benchmark.

**Special JS Feature or Syntax**

None of the provided code snippets use any special JavaScript features or syntax beyond the `class` keyword, which is a standard ES6 feature.

**Other Alternatives**

If the goal is to measure the performance of creating objects in JavaScript, other alternatives could include:

* Using `function` instead of `class`
* Creating objects using constructor functions (e.g., `new Object()` or `Object.create()`)
* Using prototype chains
* Measuring the performance of object creation with different allocation strategies (e.g., `Array.from()` or `Array.prototype.slice()`)

Keep in mind that the results may vary depending on the specific JavaScript engine, browser, and platform being tested.

Related benchmarks:

New Objects (version: 0)

Comparing performance of: Create 100000 Objects with same service vs Create 100000 Objects

Created: one year ago by: Guest

Jump to the latest result

Create 100000 Objects with same service

Create 100000 Objects

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