Benchmark: JS Variable Performance (const vs let vs var)

HTML Preparation code:

<!--your preparation HTML code goes here-->

Script Preparation code:

/*your preparation JavaScript code goes here
To execute async code during the script preparation, wrap it as function globalMeasureThatScriptPrepareFunction, example:*/
async function globalMeasureThatScriptPrepareFunction() {
    // This function is optional, feel free to remove it.
    // await someThing();
}

Tests:

TEST_1: VAR
var g = { e: [] } g.o = function(x) { g.e.push(...[1,2,3]) } g.o()
TEST_2: LET
let g = { e: [] } g.o = function(x) { g.e.push(...[1,2,3]) } g.o()
TEST_3: CONST
const g = { e: [] } g.o = function(x) { g.e.push(...[1,2,3]) } g.o()

Historical Performance Data aggregated from 28 community runs

Desktop Results:

Chrome 16 runs

TEST_1: VAR

13.7M/s

TEST_3: CONST

11.2M/s

TEST_2: LET

11.1M/s

Fastest: TEST_1: VAR (1.2x faster)

View exact numbers

✓ TEST_1: VAR: 13,674,348 ops/sec
• TEST_3: CONST: 11,238,345 ops/sec
• TEST_2: LET: 11,084,006 ops/sec

Firefox 12 runs

TEST_3: CONST

22.8M/s

TEST_2: LET

22.7M/s

TEST_1: VAR

22.7M/s

View exact numbers

✓ TEST_3: CONST: 22,833,724 ops/sec
• TEST_2: LET: 22,723,106 ops/sec
• TEST_1: VAR: 22,714,914 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
TEST_1: VAR
TEST_2: LET
TEST_3: CONST

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36

Browser/OS: Chrome 146 on Linux

View result in a separate tab

TEST_3: CONST

19.6M/s

TEST_1: VAR

19.5M/s

TEST_2: LET

19.3M/s

View exact numbers

Test name	Executions per second
✓ TEST_3: CONST	19,615,704 Ops/sec
TEST_1: VAR	19,498,620 Ops/sec
TEST_2: LET	19,318,982 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark outlined in the provided JSON assesses the performance of JavaScript variables defined using three different keywords: `var`, `let`, and `const`. Each of these keywords has distinct properties in terms of scope and mutability, influencing how they behave in JavaScript.

### Tested Options

1. **VAR**: 
   ```javascript
   var g = { e: [] }
   g.o = function(x) { g.e.push(...[1,2,3]) }
   g.o();
   ```
   - In this test case, `var` is used to declare the variable `g`, which is globally scoped or function-scoped, depending on where it's declared. 
   - Pros:
     - Flexible usage, as it can be redeclared and updated.
   - Cons:
     - Can lead to unintended behavior due to hoisting and lack of block scope, potentially causing bugs in larger applications.

2. **LET**: 
   ```javascript
   let g = { e: [] }
   g.o = function(x) { g.e.push(...[1,2,3]) }
   g.o();
   ```
   - Here, `let` is used, making `g` block-scoped.
   - Pros:
     - Prevents redeclaration within its scope, helping to avoid bugs. Its block scope also makes it clear that the variable shouldn't be accessible outside of its defined context.
   - Cons:
     - While it has enhanced packing features, it is slightly less performant than `var` in many cases because of more complex scope handling.

3. **CONST**: 
   ```javascript
   const g = { e: [] }
   g.o = function(x) { g.e.push(...[1,2,3]) }
   g.o();
   ```
   - In this test, `const` is employed. `g` is block-scoped and cannot be reassigned.
   - Pros:
     - Guarantees immutability of the reference to the variable (though the contents can still be modified if it's an object), leading to safer code.
   - Cons:
     - Constraints on reassignment can be limiting; attempting to reassign `g` would result in an error.

### Performance Results

The performance results of the JavaScript execution represented in the benchmark provide a metric called "Executions Per Second," indicating how many times the benchmark code could be executed in one second:

- `TEST_1: VAR` achieved **16,936,656 executions per second**.
- `TEST_2: LET` achieved **16,714,196 executions per second**.
- `TEST_3: CONST` achieved **16,501,599 executions per second**.

In this specific benchmark, `var` performed the best, followed closely by `let`, and `const` was marginally slower than both.

### Conclusion

This benchmark allows developers to assess the performance of variable declarations in JavaScript. While `var` shows the most raw execution speed in this scenario, the choice of variable declaration should also depend on the application's design requirements. Using `let` or `const` may incur a performance trade-off for the benefits they provide in preventing errors and enhancing maintainability.

### Other Alternatives

Alternative methods to manage variable scope and performance include:

- **Function-scoped variables**: Use of functions and closures to manage variable lifecycles.
- **Using ES6 Classes**: Instead of using constants or variables directly, creating classes encapsulates data and functions.
- **Modules**: ES6 modules allow better encapsulation and can help avoid global variable pollution.

In general, the adoption of `let` and `const` is recommended in modern JavaScript development, as they enforce better coding practices, despite possible minor performance differences in this benchmark.

JS Variable Performance (const vs let vs var) (version: 1)

Comparing performance of: `TEST_1: VAR vs TEST_2: LET vs TEST_3: CONST`

Created: one year ago by: Guest

Go to the latest result

TEST_1: VAR

TEST_2: LET

TEST_3: CONST

Historical Performance Data aggregated from 28 community runs

Desktop Results:

Chrome 16 runs

Firefox 12 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

JS Variable Performance (const vs let vs var) (version: 1)

Comparing performance of: TEST_1: VAR vs TEST_2: LET vs TEST_3: CONST

Created: one year ago by: Guest

Go to the latest result

TEST_1: VAR

TEST_2: LET

TEST_3: CONST

Historical Performance Data aggregated from 28 community runs

Desktop Results:

Chrome 16 runs

Firefox 12 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `TEST_1: VAR vs TEST_2: LET vs TEST_3: CONST`