Benchmark: pre-increment increment vs post-increment increment vs assignment operator

Script Preparation code:

let i = 0;

Tests:

pre-increment
++i
post-increment
i++
addition assignment operator
i += 1
operation plus (pre number)
i = 1 + i
operation plus (post number)
i = i + 1

Historical Performance Data aggregated from 20 community runs

Desktop Results:

Chrome 20 runs

post-increment

48.0M/s

addition assignment operator

47.7M/s

pre-increment

47.7M/s

operation plus (pre number)

46.4M/s

operation plus (post number)

42.5M/s

Fastest: post-increment (1.1x faster)

View exact numbers

✓ post-increment: 48,005,912 ops/sec
• addition assignment operator: 47,744,600 ops/sec
• pre-increment: 47,735,028 ops/sec
• operation plus (pre number): 46,394,072 ops/sec
• operation plus (post number): 42,454,720 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
pre-increment
post-increment
addition assignment operator
operation plus (pre number)
operation plus (post number)

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36

Browser/OS: Chrome 137 on Mac OS X 10.15.7

View result in a separate tab

addition assignment operator

12.5M/s

operation plus (pre number)

12.4M/s

operation plus (post number)

12.3M/s

post-increment

11.9M/s

pre-increment

11.8M/s

View exact numbers

Test name	Executions per second
✓ addition assignment operator	12,497,670 Ops/sec
operation plus (pre number)	12,373,410 Ops/sec
operation plus (post number)	12,295,141 Ops/sec
post-increment	11,896,232 Ops/sec
pre-increment	11,800,581 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Definition**

The benchmark is testing different ways to increment a variable `i` in JavaScript. The benchmark definition is provided as a JSON object, which specifies:

* Four different operations:
	+ Pre-increment (`++i`)
	+ Post-increment (`i++`)
	+ Addition assignment operator (`i += 1`)
	+ Operation with pre-number calculation (`i = 1 + i`)

**Script Preparation Code**

The script preparation code is `let i = 0;`, which initializes the variable `i` to 0 before running each test.

**Options Compared**

The benchmark is comparing four different approaches:

1. **Pre-increment (`++i`)**: This increments `i` first and then returns its new value.
2. **Post-increment (`i++`)**: This returns the current value of `i`, and then increments it.
3. **Addition assignment operator (`i += 1`)**: This adds 1 to `i` and assigns the result back to `i`.
4. **Operation with pre-number calculation (`i = 1 + i`)**: This calculates the new value of `i` by adding 1 to its current value.

**Pros and Cons**

Here's a brief summary of each approach:

* **Pre-increment (`++i`)**: Generally faster because it can be optimized by the compiler. However, it may not work as expected in certain situations.
* **Post-increment (`i++`)**: Can be slower than pre-increment due to the extra operation of returning the value before incrementing. However, it is often safer and more intuitive.
* **Addition assignment operator (`i += 1`)**: Fast and efficient because it directly modifies `i`. However, it may not be as readable or intuitive for some developers.
* **Operation with pre-number calculation (`i = 1 + i`)**: Can be slower than the other approaches due to the extra calculation. However, it is a more traditional way of incrementing a variable.

**Library and Special JS Features**

None of these approaches require any specific libraries or special JavaScript features beyond basic syntax support.

**Other Alternatives**

Some alternative ways to increment a variable in JavaScript include:

* Using `i++` with parentheses: `(i++)`
* Using a temporary variable: `let temp = i; ++temp;`
* Using a loop: `for (i = 0; ++i < someCondition; )`

However, these alternatives are not typically used for simple incrementing operations like this benchmark.

**Benchmark Results**

The latest benchmark results show the execution speed per second for each test case:

* Post-increment (`++i`): 94676856.0
* Pre-increment (`i++`): 92663480.0
* Addition assignment operator (`i += 1`): 53744980.0
* Operation with pre-number calculation (`i = 1 + i`): 52630928.0

These results suggest that post-increment and addition assignment operators are faster than pre-increment, while the operation with pre-number calculation is slower.

Overall, this benchmark helps compare the performance of different incrementing operations in JavaScript and provides insights into the execution speed and efficiency of each approach.

pre-increment increment vs post-increment increment vs assignment operator (version: 0)

Comparing performance of: `pre-increment vs post-increment vs addition assignment operator vs operation plus (pre number) vs operation plus (post number)`

Created: 4 years ago by: Guest

Go to the latest result

pre-increment

post-increment

addition assignment operator

operation plus (pre number)

operation plus (post number)

Historical Performance Data aggregated from 20 community runs

Desktop Results:

Chrome 20 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

pre-increment increment vs post-increment increment vs assignment operator (version: 0)

Comparing performance of: pre-increment vs post-increment vs addition assignment operator vs operation plus (pre number) vs operation plus (post number)

Created: 4 years ago by: Guest

Go to the latest result

pre-increment

post-increment

addition assignment operator

operation plus (pre number)

operation plus (post number)

Historical Performance Data aggregated from 20 community runs

Desktop Results:

Chrome 20 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `pre-increment vs post-increment vs addition assignment operator vs operation plus (pre number) vs operation plus (post number)`