Increment(++) Weirdness in JavaScript

The increment(++) and decrement(--) operators are very useful in JavaScript but can be misleading depending on whether they are used as a prefix operator (as in ++x) or a postfix operator(as in x++).

Increment as a postfix operator:

let a = 3;
a++;

console.log(a); // a is 4

Ok, everything seems normal here. The increment operation (a++) executes and the new value of a is 4.
Super useful right? We also use the postfix increment in for loops constantly:

for(let = 0; i < whatever; i++) {
// loop-de-loop
}

So, we

• initialize i at zero.
• Then, if i is less than "whatever",
• i equals i + 1 i.e we add 1 to i

The increment in this case is adding another go-round of the loop, until it reaches "whatever".
Awesome, so far, so good.

Check out the next example for incoming weirdness.

let x = 3;
//POSTFIX 
let y = x++;

console.log(x); // x is 4
console.log(y); // y is 3 because assignment of y to value of 
// x happens BEFORE increment

So why does this happen?

• Under the hood, JavaScript executes the assignment of y to the value of x,
• THEN continues and evaluates x++.

When using increment (or decrement) as a prefix operator, the behavior is what you would expect:

let alpha = 3;
//PREFIX
let beta = ++alpha;

console.log(alpha); // x is 4
console.log(beta); // y is 4 because assignment happens AFTER increment

• JavaScript engine sees y is assigned to something about to be incremented because of the ++ operator,
• so JS evaluates increment
• THEN finally assigns value to y.

I decided to write this after being sloppy with using the postfix operator and seeing weird results, so I wanted to understand what was going on. Now you will too, happy coding!