We Keep Coding

Why position of increment operator matters [duplicate]

In JavaScript you can use ++ operator before (pre-increment) or after the variable name (post-increment). What, if any, are the differences between these ways of incrementing a variable?

Same as in other languages:
++x (pre-increment) means "increment the variable; the value of the expression is the final value"
x++ (post-increment) means "remember the original value, then increment the variable; the value of the expression is the original value"
Now when used as a standalone statement, they mean the same thing:
x++;
++x;
The difference comes when you use the value of the expression elsewhere. For example:
x = 0;
y = array[x++]; // This will get array[0]
x = 0;
y = array[++x]; // This will get array[1]

++x increments the value, then evaluates and stores it.
x++ evaluates the value, then increments and stores it.
var n = 0, m = 0;
alert(n++); /* Shows 0, then stores n = 1 */
alert(++m); /* Shows 1, then stores m = 1 */
Note that there are slight performance benefits to using ++x where possible, because you read the variable, modify it, then evaluate and store it. Versus the x++ operator where you read the value, evaluate it, modify it, then store it.

As I understand them if you use them standalone they do the same thing. If you try to output the result of them as an expression then they may differ. Try alert(i++) as compared to alert(++i) to see the difference. i++ evaluates to i before the addition and ++i does the addition before evaluating.
See http://jsfiddle.net/xaDC4/ for an example.

I've an explanation of understanding post-increment and pre-increment. So I'm putting it here.
Lets assign 0 to x
let x = 0;
Lets start with post-increment
console.log(x++); // Outputs 0
Why?
Lets break the x++ expression down
x = x;
x = x + 1;
First statement returns the value of x which is 0
And later when you use x variable anywhere, then the second statement is executed
Second statement returns the value of this x + 1 expression which is (0 + 1) = 1
Keep in mind the value of x at this state which is 1
Now lets start with pre-increment
console.log(++x); // Outputs 2
Why?
Lets break the ++x expression down
x = x + 1;
x = x;
First statement returns the value of this x + 1 expression which is (1 + 1) = 2
Second statement returns the value of x which is 2 so x = 2 thus it returns 2
Hope this would help you understand what post-increment and pre-increment are!

var a = 1;
var b = ++a;
alert('a:' + a + ';b:' + b); //a:2;b:2
var c = 1;
var d = c++;
alert('c:' + c + ';d:' + d); //c:2;d:1
jsfiddle

var x = 0, y = 0;
//post-increment: i++ returns value then adds one to it
console.log('x++ will log: ', x++); //0
console.log('x after x++ : ', x); //1
//pre-increment: adds one to the value, then returns it
console.log('++y will log: ', ++y); //1
console.log('y after ++y : ', y); //1

It is clearer and faster to use ++i if possible :
++i guarantees that you are using a value of i that will remains the same unless you change i
i++ allows to use a value of i which will change in the "near future", it is not desirable if possible
Of course, it's not really much faster, only a little.

Incremental issue in JS recursion [duplicate]

In JavaScript you can use ++ operator before (pre-increment) or after the variable name (post-increment). What, if any, are the differences between these ways of incrementing a variable?

Same as in other languages:
++x (pre-increment) means "increment the variable; the value of the expression is the final value"
x++ (post-increment) means "remember the original value, then increment the variable; the value of the expression is the original value"
Now when used as a standalone statement, they mean the same thing:
x++;
++x;
The difference comes when you use the value of the expression elsewhere. For example:
x = 0;
y = array[x++]; // This will get array[0]
x = 0;
y = array[++x]; // This will get array[1]

++x increments the value, then evaluates and stores it.
x++ evaluates the value, then increments and stores it.
var n = 0, m = 0;
alert(n++); /* Shows 0, then stores n = 1 */
alert(++m); /* Shows 1, then stores m = 1 */
Note that there are slight performance benefits to using ++x where possible, because you read the variable, modify it, then evaluate and store it. Versus the x++ operator where you read the value, evaluate it, modify it, then store it.

As I understand them if you use them standalone they do the same thing. If you try to output the result of them as an expression then they may differ. Try alert(i++) as compared to alert(++i) to see the difference. i++ evaluates to i before the addition and ++i does the addition before evaluating.
See http://jsfiddle.net/xaDC4/ for an example.

I've an explanation of understanding post-increment and pre-increment. So I'm putting it here.
Lets assign 0 to x
let x = 0;
Lets start with post-increment
console.log(x++); // Outputs 0
Why?
Lets break the x++ expression down
x = x;
x = x + 1;
First statement returns the value of x which is 0
And later when you use x variable anywhere, then the second statement is executed
Second statement returns the value of this x + 1 expression which is (0 + 1) = 1
Keep in mind the value of x at this state which is 1
Now lets start with pre-increment
console.log(++x); // Outputs 2
Why?
Lets break the ++x expression down
x = x + 1;
x = x;
First statement returns the value of this x + 1 expression which is (1 + 1) = 2
Second statement returns the value of x which is 2 so x = 2 thus it returns 2
Hope this would help you understand what post-increment and pre-increment are!

var a = 1;
var b = ++a;
alert('a:' + a + ';b:' + b); //a:2;b:2
var c = 1;
var d = c++;
alert('c:' + c + ';d:' + d); //c:2;d:1
jsfiddle

var x = 0, y = 0;
//post-increment: i++ returns value then adds one to it
console.log('x++ will log: ', x++); //0
console.log('x after x++ : ', x); //1
//pre-increment: adds one to the value, then returns it
console.log('++y will log: ', ++y); //1
console.log('y after ++y : ', y); //1

It is clearer and faster to use ++i if possible :
++i guarantees that you are using a value of i that will remains the same unless you change i
i++ allows to use a value of i which will change in the "near future", it is not desirable if possible
Of course, it's not really much faster, only a little.

Javascript reduce accumulator unexpected behavior [duplicate]

In JavaScript you can use ++ operator before (pre-increment) or after the variable name (post-increment). What, if any, are the differences between these ways of incrementing a variable?

Same as in other languages:
++x (pre-increment) means "increment the variable; the value of the expression is the final value"
x++ (post-increment) means "remember the original value, then increment the variable; the value of the expression is the original value"
Now when used as a standalone statement, they mean the same thing:
x++;
++x;
The difference comes when you use the value of the expression elsewhere. For example:
x = 0;
y = array[x++]; // This will get array[0]
x = 0;
y = array[++x]; // This will get array[1]

++x increments the value, then evaluates and stores it.
x++ evaluates the value, then increments and stores it.
var n = 0, m = 0;
alert(n++); /* Shows 0, then stores n = 1 */
alert(++m); /* Shows 1, then stores m = 1 */
Note that there are slight performance benefits to using ++x where possible, because you read the variable, modify it, then evaluate and store it. Versus the x++ operator where you read the value, evaluate it, modify it, then store it.

As I understand them if you use them standalone they do the same thing. If you try to output the result of them as an expression then they may differ. Try alert(i++) as compared to alert(++i) to see the difference. i++ evaluates to i before the addition and ++i does the addition before evaluating.
See http://jsfiddle.net/xaDC4/ for an example.

I've an explanation of understanding post-increment and pre-increment. So I'm putting it here.
Lets assign 0 to x
let x = 0;
Lets start with post-increment
console.log(x++); // Outputs 0
Why?
Lets break the x++ expression down
x = x;
x = x + 1;
First statement returns the value of x which is 0
And later when you use x variable anywhere, then the second statement is executed
Second statement returns the value of this x + 1 expression which is (0 + 1) = 1
Keep in mind the value of x at this state which is 1
Now lets start with pre-increment
console.log(++x); // Outputs 2
Why?
Lets break the ++x expression down
x = x + 1;
x = x;
First statement returns the value of this x + 1 expression which is (1 + 1) = 2
Second statement returns the value of x which is 2 so x = 2 thus it returns 2
Hope this would help you understand what post-increment and pre-increment are!

var a = 1;
var b = ++a;
alert('a:' + a + ';b:' + b); //a:2;b:2
var c = 1;
var d = c++;
alert('c:' + c + ';d:' + d); //c:2;d:1
jsfiddle

var x = 0, y = 0;
//post-increment: i++ returns value then adds one to it
console.log('x++ will log: ', x++); //0
console.log('x after x++ : ', x); //1
//pre-increment: adds one to the value, then returns it
console.log('++y will log: ', ++y); //1
console.log('y after ++y : ', y); //1

It is clearer and faster to use ++i if possible :
++i guarantees that you are using a value of i that will remains the same unless you change i
i++ allows to use a value of i which will change in the "near future", it is not desirable if possible
Of course, it's not really much faster, only a little.

What is the logic behind JavaScript In-/ Decrement? Could someone clearify this?

++ Increment
x = ++y // When y = 6 x = 6
x = y++ // And y = 6 x = 5
-- Decrement
x = --y // When y = 4 x = 4
x = y-- // When y = 4 x = 5
Could someone clearify this?
Thank you.

The only slightly tricky case there is:
x = --y // When y = 4 x = 4
You must be looking at y afterward. If you looked at y before, you'd see a 5.
The basic rules for prefix decrement (--y) and postfix decrement (y--) are:
Either way, the operand (y in this case) is decremented by 1. The only difference is what the result of that expression (--y or y--) is.
If the operator comes before the operand (--y) it's a "prefix" decrement: The decrement happens before the result of the expression is taken. So the result is the value of y after it was decremented.
If the operator comes after the operand (y--) it's a "postfix" decrement: The decrement happens after the result of the expression is taken. So the result is the value before it was decremented.
Examples:
var x, y;
y = 5;
snippet.log("Before prefix decrement: y = " + y);
x = --y; // Result is the value **after** the decrement
snippet.log("After prefix decrement: x = " + x + ", y = " + y);
y = 5;
snippet.log("Before postfix decrement: y = " + y);
x = y--; // Result is the value **before** the decrement
snippet.log("After postfix decrement: x = " + x + ", y = " + y);
<!-- Script provides the `snippet` object, see http://meta.stackexchange.com/a/242144/134069 -->
<script src="http://tjcrowder.github.io/simple-snippets-console/snippet.js"></script>

In both cases y will have the same final value. The only difference will be in the return value of the expression itself.
++y will return the value after incrementing.
y++ will return the value before incrementing.

When the operator precedes the variable, it changes its value before any processing. When the variable precedes the operator, the value is changed after processing.
y = ++x is identical to:
x = x + 1;
y = x;
and y = x++ is identical to:
y = x;
x = x + 1;

Since your main question is:
The logic behind ...
The answer to that part specifically are processors. Many have had the INC and DEC instructions for a very long time and since C was created to match the processor instructions, it was thought that having operators such as ++ and -- would help in optimizing some code.
INC WORD [BP+4] ; increment value at address BP+4 by one
DEC WORD [SP+16] ; decrement value at address SP+16 by one
RISC processors generally require you to use ADD and SUB instead. The result is pretty much the same in modern processor because speed of execution of such instructions was greatly enhanced, especially with large instruction caches.
Java and JavaScript are spawned of C and thus inherited these.
Specifically, there is the 68000 processor that has instructions such as:
MOV.W D1, (A1)+ ; copy D1 at address A1, then increment A1 by size of D1
MOV.W D2, -(SP) ; decrement stack by size of D2, then copy D2 at address SP
which include hidden increment (the +) and hidden decrement (the -) in the instruction.
In these cases, C matched the processor behavior perfectly. You could write something like:
*a1++ = d1;
*--sp = d2;
And each line becomes just one instruction in assembly language. Notice that the ++ and -- used with the stack work like a charm:
*--sp = d1; // move the stack pointer, then save value on the stack
... // do some work
d1 = *sp++; // restore from the stack, then move the stack pointer back
Here we want to use register d1, so we save it on the stack, the automatic pre-decrement works exactly as required. Then before leaving the function, we restore from the stack, again, the automatic post-increment works exactly as expected. The INTEL processors have specialized instructions instead: PUSH and POP. But that's the same concept.
Of course, with C++ and other object oriented languages (including Java and JavScript), that has evolved quite a bit now and it is easy to lose the reason why we have had these ++ and -- operators.

What does x++ in JavaScript do?

I have a very short question, but it really confused me.
var y = 3, x = y++;
What is the value of x?
I thought the answer should be 4, but actually it's 3.
Can anyone explain me the reason?

y++ is called post-increment -- it increments the variable after it returns the original value as the value of the expression. So
x = y++;
is equivalent to:
temp = y;
y = y + 1;
x = temp;
If you want to return the new value, you should use ++y. This is called pre-increment because it increments the variable before returning it. The statement
x = ++y;
is equivalent to:
y = y + 1;
x = y;

In y++, ++ is called "post-increment operator". It first uses the value of y, then increments y. In this, is contrasts to a "pre-increment operator", ++y, which first increments y, then returns the incremented value.

The ++ operator does two things. It increments a variable and it returns the value of the variable.
If you prefix it, ie ++y, it will return the value after the increment (in your case, 4). If you postfix (y++)it, it will return the value before the increment (in your case 3. Note that the value of y is now still 4, but x was assigned before y was incremented).

var y = 3;
x = ++y;
console.log(x);
This will result in 4
This is called "pre-increment". Where it returns the incremented value .
y++ is post-increment, which returns the original value.