Benchmark: Nested with statements

Script Preparation code:

let smthg = {abc:123}
let myObj = {property: 1000}
myObj.myObj = myObj
for(let i = 5; i--;) window[`go${i}`] = Function(`with(myObj)`.repeat(i)+`{vari = 456; smthg = 789}`)

Tests:

Normal
go0()
1 with statement
go1()
2 with statements
go2()
3 with statements
go3()
4 with statements
go4()

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Normal
1 with statement
2 with statements
3 with statements
4 with statements

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 29 days ago)

User agent: Mozilla/5.0 (X11; CrOS x86_64 14541.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Chrome OS 14541.0.0

View result in a separate tab

Test name	Executions per second
Normal	45365668.0 Ops/sec
1 with statement	1859805.2 Ops/sec
2 with statements	1094624.8 Ops/sec
3 with statements	694999.0 Ops/sec
4 with statements	569987.9 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark "Nested with statements" evaluates the performance of JavaScript functions that use the `with` statement in varying nested levels. The `with` statement extends the scope chain for the duration of the block, allowing for the properties of an object to be accessed directly without needing to reference the object each time. In this benchmark, the focus is on testing how the use of multiple `with` statements impacts the execution speed.

### Benchmarked Options
1. **Normal:** This test case runs the basic function `go0()` without any `with` statements.
2. **1 with statement:** `go1()` introduces one `with` statement, encapsulating the property access within the object `myObj`.
3. **2 with statements:** `go2()` adds a second `with` statement, increasing the complexity of the scope chain.
4. **3 with statements:** `go3()` increases this to three nested `with` statements.
5. **4 with statements:** `go4()` extends it to four nested `with` statements.

### Results Overview
The results show a substantial decline in performance as the number of nested `with` statements increases. Here are the raw performance metrics in executions per second for each scenario:

- **Normal:** 88,875,592.0 executions/second
- **1 with statement:** 3,980,551.25 executions/second
- **2 with statements:** 2,356,184.0 executions/second
- **3 with statements:** 1,562,563.75 executions/second
- **4 with statements:** 1,176,462.5 executions/second

### Pros and Cons
**Pros of using `with`:**
- It can simplify code for accessing properties of an object, reducing repetitive code when accessing multiple properties.

**Cons:**
- **Performance Implications:** As seen in the benchmark results, using multiple `with` statements can significantly degrade performance due to increased complexity in scope resolution.
- **Readability and Maintainability:** Code that uses `with` can be harder to read and understand, especially for those unfamiliar with it, and can lead to bugs if object properties conflict with variables in the same scope.
- **Variable Scope Issues:** The `with` statement creates potential pitfalls by adding properties to the local scope which might lead to confusing bugs or unexpected behaviors.

### Library/Feature Considerations
In this benchmark, no external libraries are used; the tests are purely based on native JavaScript behavior and its intrinsic `with` statement.

### Alternative Approaches
- **Use of Closures:** Instead of `with`, closures can be used to create a scoped context where the properties can be accessed directly. This often retains performance benefits and improves readability.
- **Destructuring Assignment:** Using destructuring can simplify property access without the performance hit of `with`. For example, `const {property} = myObj` allows direct access to `property`.
- **Explicit Scope:** Simply referencing an object directly using `myObj.property` can often be clearer and avoids ambiguity, making debugging easier.

### Conclusion
This benchmark illustrates the clear performance degradation associated with using multiple `with` statements, reinforcing the idea that while syntactic sugar might make for concise code, it can lead to hidden costs in performance and maintainability. Software engineers should consider alternative structural approaches to maintain both performance and readability in their JavaScript code.

Related benchmarks:

Nested with statements (version: 1)

Comparing performance of: Normal vs 1 with statement vs 2 with statements vs 3 with statements vs 4 with statements

Created: one month ago by: Guest

Jump to the latest result

Normal

1 with statement

2 with statements

3 with statements

4 with statements

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):