Benchmark: array vs frozen array loop

Script Preparation code:

var a = [
    /@atlassian\/parcel/,
    /@parcel\//,
    /@oxc-resolver\/.+/,
];
var b = Object.freeze([
    /@atlassian\/parcel/,
    /@parcel\//,
    /@oxc-resolver\/.+/,
]);

Tests:

normal array
for (const matcher of a) { if (matcher.test("SOMETHING")) { return 'yes'; } return 'no' }
frozen array
for (const matcher of b) { if (matcher.test("SOMETHING")) { return 'yes'; } return 'no' }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
normal array
frozen array

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
normal array	11036072.0 Ops/sec
frozen array	8346339.5 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark described in the provided JSON assesses the performance differences between iterating over a normal array and a frozen array in JavaScript. Let’s break down the key elements, options compared, their pros and cons, and other relevant considerations.

### Benchmark Overview

1. **Benchmark Targets:**
   - **Normal Array (`a`):** This is a mutable array that can be modified after its initial creation.
   - **Frozen Array (`b`):** This is an immutable array created using `Object.freeze()`, which prevents the array from being modified (no additions, deletions, or alterations of its elements).

2. **Test Cases:**
   - **Normal Array Test:** This loops through the mutable array elements using a `for...of` loop to evaluate if any regular expression (`matcher`) matches a given string ("SOMETHING").
   - **Frozen Array Test:** Similar to the normal array, but the loop is executed on the frozen array.

### Performance Results

- **Normal Array Execution Speed:** Approximately 11,036,072 executions per second.
- **Frozen Array Execution Speed:** Approximately 8,346,339 executions per second.

### Analysis of Options

#### 1. **Normal Array**
   - **Pros:**
     - Dynamic: Elements can be changed, added, or removed, providing flexibility for various use cases.
     - Generally faster in this benchmark, which could be attributed to less overhead in array handling by the JavaScript engine.
   - **Cons:**
     - Potential for unintentional modifications, which can lead to bugs if the state of the array is altered unexpectedly.

#### 2. **Frozen Array**
   - **Pros:**
     - Immutability: Provides guaranteed stability of the data since the array can't be changed after creation. This is useful in scenarios where data integrity is critical, such as functional programming patterns.
     - Safer in multi-threaded contexts or when passing objects between different parts of an application, reducing side effects.
   - **Cons:**
     - Performance overhead observed in this benchmark, likely due to the extra checks the JavaScript engine performs to ensure the frozen array remains unchanged.
     - Less flexibility in terms of state management.

### Special Considerations

- **`Object.freeze()`:** This built-in JavaScript method is used to create immutable objects. It is crucial for developers needing to maintain a consistent state of objects throughout their application, preventing accidental changes to data that could lead to bugs.
- **Regular Expressions Usage:** In both tests, the `matcher.test()` method is employed, which checks if a pattern (regular expression) matches a specified string. This is a common use case in applications requiring string validation.

### Alternatives

- **Using other immutable data structures:** Libraries like Immutable.js or immer can be alternatives for managing immutable data, offering additional functionalities like efficient updates (without complete copying).
- **Typed Arrays:** For specific numeric operations, typed arrays may yield better performance, particularly in numeric calculations.
- **Proxy Objects:** JavaScript's Proxy can be used to add a layer of behavior to regular objects, including enforcing immutability through trap methods, but it comes with its overhead and complexity.

### Conclusion

This benchmark provides insights into the performance trade-offs between mutable and immutable structures in JavaScript. While normal arrays may offer better performance in this instance, the choice between using them or frozen arrays often depends on the specific needs of the application regarding data integrity, performance requirements, and code maintainability. Understanding the underlying mechanics and implications of using each is essential for software engineers to make informed decisions in their development process.

Related benchmarks:

array vs frozen array loop (version: 0)

Comparing performance of: normal array vs frozen array

Created: 2 months ago by: Registered User

Jump to the latest result

normal array

frozen array

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):