Why is $a + ++$a == 2?

A preincrement operator "++" takes place before the rest of the expression it's in evaluates. So it is actually:

echo $l + ++$l; // (1) + (0+1) === 2 

a + b a = 1 b = ++a := 2 

Why do you expect something else?

In PHP:

$a = 0; $c = $a + ++$a; 

Operator precedence visualized:

$c = ($a) + (++$a); 

Evaluation sequence visualized:

$a = 0; ($a = 0) $a = 1; (++$a) $c = $a + $a (1 + 1); 

Or written out:

The moment the sum operation is performed, $a is already 1 because ++$a has been already evaluated. The ++ operator is evaluated before the + operator.

For the fun:

$a++ + ++$a 

Results in 2, too. However if you compare it as an expression, it's not equal:

$a++ + ++$a == $a + ++$a 

Where as

$a++ + ++$a == $a-- + --$a 

is "equal".

See Also:

• Order of evaluation in PHP (Sep 2013; by NikiC) (via)

My Evaluation Order in PHP blog post explain this in detail, but here is the basic idea:

• Operator precedence and associativity have nothing to do with evaluation order.
• PHP does not guarantee an evaluation order. The order can change between PHP versions without notice and can also be different depending on the surrounding code.
• "Normally" PHP will evaluate left-to-right, with the exception of accesses to "simple" variables (like $a). Accesses to simple variables will be executed after more complex expressions, regardless in which order the expressions actually occur.
• In this particular case it means that ++$a is run first because it is a complex expression and only then the value of $a is fetched (it is already 1 at this point). So effectively you are summing 1 + 1 = 2.
• The reason that simple variables are fetched after complex expressions is the Compiled Variables (CV) optimization. If you disable this optimization, for example by using the @ error suppression operator, all expressions are evaluated left-to-right, including simple variable fetches.
• In this particular case it means that @($a + ++$a) will result in 1, because first $a is fetched (0 at that time) and incremented only after that.

++ is the higher precedence operator, so it gets applied first.

So now l = 1.

So 1 + 1 = 2.

When you do your ++$l (preincrement), it will be done before your addition -> check operator precedence).

So, the value of $l will be 1 before your addition :

echo $l + ++$l; // $l => 1 because ++$l is done first 

So your answer will be 2.

But when you do :

echo $l // you will get your first value which is $l => 1 

So your answer will be 1.

This behaviour can be confirmed by inspecting how PHP compiles your script, for example:

$a = 0; echo $a + ++$a; 

Compiles into the following opcodes, which are then executed:

compiled vars: !0 = $a line # * op fetch ext return operands --------------------------------------------------------------------------------- 1 0 > ASSIGN !0, 0 1 PRE_INC $1 !0 2 ADD ~2 !0, $1 3 ECHO ~2 4 > RETURN null 

This translates to the following equivalent script:

$a = 0; // ASSIGN $tmp = ++$a; // PRE_INC echo $a + $tmp; // ADD, ECHO 

Conclusion

By the time $a is evaluated as the left hand expression of $a + (++$a), it has already been incremented, because ++$a was evaluated first.

Obviously, this behaviour should not be relied upon; in any language for that matter.

Check the increment operator manual:

http://www.php.net/manual/en/language.operators.increment.php

Or see this codepad: http://codepad.org/Y3CnhiLx

<?php $n = 0; $m = 0; echo '++ before:'; echo $n+ ++$n; echo PHP_EOL; echo '++ after:'; echo $m+ $m++; echo PHP_EOL; echo 'n:'.$n; echo PHP_EOL; echo 'm:'.$m; 

Outputs:

++ before:2 ++ after:1 n:1 m:1 

As you may know we have two increment operator, one is pre-increment and second is post-increment. Pre-increment increase the value of integer before it use in expression, on the other hand post increment increase value of number after it used in expression.

suppose you have variable $a and variable $b as below

$a=0;

$b=++$a gives the value of b=1

while

$b=$a++ gives the value b=0

The output of your code varies with PHP version as seen here

Output for 4.3.0 - 5.0.5
1
1

In the above case the left hand side of + operator is evaluated first (0, 1, +).

Output for 5.1.0 - 5.5.0alpha4
2
1

In the above case the right hand side of + operator is evaluated first (1, 1, +).

This is in accordance with interjay's answer that in PHP there is no guarantee about the order of evaluation of sub-expresions. The assumption that the output could be 1, 1 is correct, so are that answers that claim that the output could be 1, 2.

First obvious part is that ++ have higher priority than +.

Second part is that php engine doesn't store value from first operand into another anonymous variable. So $l + ++$l is not an qeuivalent for

$a = $l; $b = ++$l; return $a + $b; 

As mentioned before there is a difference in x++ and ++x. You can interpret it in the way that

x++; 

increments after the semicolon

and

++x; 

increments on evaluation of the expression

So it seems that your expression is evaluated from right to left

echo $l + ++$l; 

1. Get $l: $l = 0
2. Apply ++: ++$l = 1
3. Get $l: $l = 1
4. Apply +: $l + $l = 1 + 1 = 2

All statements are executed from right to left. So the value is first incremented than the value of your variable is = 1 so 1+1=2