I have a program in php that will based on post and pre increment like
<?php
$x=5;
echo $x+++$x++;
?>
I execute program and output is 11 but i confused why it prints 11.can anyone please explain how this program execute.
The postincrement operator increments the variable, but returns its old value. So $x++ is equivalent to:
($temp = $x, $x = $x + 1, $temp)
When you do it twice in an expression, it's like:
echo ($temp1 = $x, $x = $x + 1, $temp1) + ($temp2 = $x, $x = $x + 1, $temp2);
The first part sets $temp1 = 5 and increments $x to 6. The second part sets $temp2 = 6 and increments $x to 7. Then it does $temp1 + $temp2 and echoes the result, which is 5 + 6 = 11.
x++ is called postincrement, it returns x and then increases x by one. Opposite is ++x ( preincrement ), increase x by one and then return. + in the middle is arithmetic operator for addition.
$x = 5;
echo $x++ + $x++; // 11
echo $x; // 7
This: echo $x+++$x++ is the same as:
echo ( ($x++) + ($x++) )
So, as you can see, its adding $x++ plus $x++
In PHP, when you run $x++, is the same as saying $x = $x + 1 but returning the original value of $x. (As said in the comments)
So for example if you do this:
$x = 5;
echo $x++; //outputs $x, then adds 1
echo $x++; //outputs $x, then adds 1
/*
THIS IS WHAT THE ABOVE DOES:
set x equal to 5
echo x (OUTPUTS 5), then add 1.
echo x (OUTPUTS 6), then add 1.
*/
With that said, in $x+++$x++, the first reference of $x is when its value is still 5 (before it is incremented) and the second reference to $x is then when its value is 6 (before it is again incremented), Therefore: 5 + 6 = 11
Source: http://php.net/manual/en/language.operators.increment.php
Related
I needed to increment the for loop by 7 by 7 and used the $x + 7 method as below. However, it didn't work.
for ($x = 1; $x <= 31; $x + 7) {
echo $x ."\n";
}
I solved the problem by redefining the variable as below but I am still wondering why the first method is not working.
for ($x = 1; $x <= 31; $x += 7) {
echo $x ."\n";
}
I usually use the $x++ method to increase the value. Why is $x + 7 different?
You can try: https://glot.io/snippets/g16a4it4il
$x + 7 does not alter x. It simply evaluates to 7 more than $x. To add 7 to $x, you can either:
$x += 7
or
$x = $x + 7
$x++ increments $x by 1. It is roughly equivalent to $x = $x + 1 or $x += 1. (Although when used in an expression, $x++ evaluates to the value of $x before the increment happens; for further information see What's the difference between ++$i and $i++ in PHP?)
The for loop works by changing $x every iteration until $x <= 31 is no longer true.
$x + 7 doesn't change $x, so it'll always remain 1
How do I check that x is 1 greater (ahead) of y in a modulo sense (mod 3)?
This is when x = 0 and y = 2, when x = 1, y = 0 and when x = 2, y = 1.
I tried testing like this:
php -a
php > $x = 0;
php > $y = 2;
php > echo ($x - $y) % 3;
-2
php > $x = 1;
php > $y = 0;
php > echo ($x - $y) % 3;
1
php > $x = 2;
php > $y = 1;
php > echo ($x - $y) % 3;
1
It is not working for the case where x = 0 and y = 2. How can I calculate this so that $x is 'ahead' of $y by 1 in a modulo sense?
I will first explain my understanding of your following sentence:
How do I check that x is 1 greater (ahead) of y in a modulo sense (mod 3)?
Following the examples provided, I assume you mean that, if 1 is added to $y, and we take the mod 3 of $y, we would get the mod 3 of $x.
With that in mind, we could write the following code, witch would return true if $x is "ahead" of $y by 1. (I hope you can abstract that example to whatever situation you are facing):
function check($x, $y, $mod) {
return $x % $mod == ($y + 1) % $mod;
}
//$x = 0 and $y = 2
echo check(0,2,3); //returns true
//$x = 1 and $y = 0
echo check(1,0,3); //returns true
//$x = 2 and $y = 1
echo check(2,1,3); //returns true
//$x = 0 and $y = 1
echo check(0,1,3); //returns false because $x is 2 "ahead" of $y
If you want a more generalized version of the function, with an arbitrary difference, you can use this (it should work with positive and negative differences):
function check($x, $y, $mod, $diff) {
return $x % $mod == ($y + $diff) % $mod;
}
Why is it that you used 0 for x and 2 for y? (Sorry, but I'm not much of an algebraist.)
Although your situations are pretty much clarified, it doesn't make sense (at least for me) that x would be 1 bit ahead of y when it is clearly 0 < 2.
As we know, the statement (0 - 2) % 3 would be -2 because the mod is 3, and 0 - 2 is -2, so the result is -2.
Mathematics can have some illogical sense (in my opinion) sometimes, so its worth noting that 0 isn't ahead of 2 (in the sense of programming variables) at all.
And to actually answer your question on calculation, you could have x = 0 and y = -1 as your variables instead, as per se the logic of your statement, then just increment by 1 for both variables, and the result is still the same.
Proof:
<?php
$x = 0
$y = -1
echo ($x - $y) % 3 // outputs 1
echo (++$x - ++$y) % 3 // still outputs 1
echo (++$x - ++$y) % 3 // also outputs 1
echo (++$x - ++$y) % 3 // yep, still the same
echo (++$x - ++$y) % 3 // alright, you get the deal
?>
According to the opcodes it should be 12. Am I getting it wrong?
number of ops: 8
compiled vars: !0 = $x
line #* E I O op fetch ext return operands
-------------------------------------------------------------------------
3 0 E > EXT_STMT
1 ASSIGN !0, 5
5 2 EXT_STMT
3 POST_INC ~2 !0
4 POST_INC ~3 !0
5 ADD ~4 ~2, ~3
6 ECHO ~4
7 7 > RETURN 1
branch: # 0; line: 3- 7; sop: 0; eop: 7; out1: -2
path #1: 0,
Edit
Also ($x++)+($x++); returns the same result (11). Actually this was the main reason for the question and opcode investigation.
It took me a few reads, but $x=5; $x++ + $x++; works like this:
In the case of a $x++, it first 'gets used', then increased:
Set $x to 5
Place $x onto stack (which is 5)
Increment(++) ($x is now 6, stack=[5])
Add $x onto stack (stack=[5,6], so 5+6 -> $x=11)
Adding is done, that outcome is 11
Increment $x(++) (which is isn't used further, but $x is now 7)
Actually, in this specific example, if you would echo $x;
it would output 7. You never reassign the value back to $x, so $x=7 (you incremented it twice);
$x = 5;
$a = $x++ + $x++;
the expression line will be executed like this:
1st occurrence of $x++ in the statement will increment $x value by 1 so it will become 6 and
in 2nd occurrence, $x will be having value 6;
So $a = 5 + 6;
So final result $a will be 11.
++ has higher precedence than + operator
(x++) will return the value of x first then increment it by 1
$x = 2
$x++ // return 2, then increment it to 3
x+++x++ is evaluated like the following
1. Get x value first which is 5
2. Then it will be incremented to 6
3. But first x value will be 5 because (x++) statement will return 5 first then increment the value
4. Then + operator is encountered
5. Next x will have 6 as value not 7 for the same reason (x++) will return the x value first and then increment it
6. So 5+6 is 11
7..At the end, x value will be 7
Same goes for ($x++)+($x++)
grouping operator () has left to right associatevity. First ($x++) executes first.
$x = 5
($x++) returns 5 and then increment $x by 1. Same as before.
then last ($x++) executes. It returns 6 and then increment $x to 7
so same 5+6 // 11 is returned back
The post increment operator increment the variable, but returns its old value.
So $x++ is equivalent to:
($temp = $x, $x = $x + 1, $temp)
When you do it twice in an expression, it's like:
echo ($temp1 = $x, $x = $x + 1, $temp1) + ($temp2 = $x, $x = $x + 1, $temp2);
The first part sets $temp1 = 5 and increments $x to 6.
The second part sets $temp2 = 6 and increments $x to 7.
Then it does $temp1 + $temp2 and echoes the result, which is 5 + 6 = 11.
You are using the post-increment operator ($x++). If you would like to use the incremented value for the addition you should use the pre-increment operator (++$x).
Therefore if $x = 5
$x++ + $x++ equals 5+6 = 11
++$x + $x++ equals 6+6 = 12
$x++ + ++$x equals 5+7 = 12
$++x + ++$x equals 6+7 = 13
Yet in all cases, x is equal to 7 afterward.
$x = 5;
echo $x++ + $x++;
prints 11 as first $x++ returns 5 and then after that it increments, the second $x++ returns 6 and the only value in incremented. so actual addition is 5+6 which gives 11.
++$x + $x++ will be 12
And ++$x + ++$x will be 13
when you use $x++ $x get +1 as soon it's value is use, but the value that will gonna be use is the one it has before the increment, so when yo do:
$x=5; $x+++$x++;
$x+++$x++ is 11, but $x will be 7
Can anyone elexplain to me why the output of this code is 22 not 21?
$x=10;
$x+=++$x;
echo $x;
$x += ++$x;
The right-hand side of this assignment is evaluated first:
increment $x → $x is now 11, result of expression ++$x is 11
take the value of $x (11) and add the result of step 1 to it → 22
assign the result of step 2 to $x
x is being incremented by the stored incremented value of x.
x += (x = x + 1).
Internally, this is evaluated as:
# op ext return operands
-------------------------------------
1 ASSIGN !0, 10
2 PRE_INC $2 !0
3 ASSIGN_ADD 0 !0, $2
4 ECHO !0
Assign 10 to $x (referred to above as !0)
Pre-increment $x, i.e.
Add 1 to $x
Return the new result (11)
Increase $x (now 11) by the return value from step 2 (also 11)
Echo the result (22)
(Edited the VLD output for readability, see the full version here: https://3v4l.org/mftI4/vld#output)
Its all about order of operations.
$a+=$b is just a shorthand for $a = $a + $b. So now, "unroll" your 2nd line with that knowledge:
$x = $x + (++$x);
To assign value to $x, we must 1st evaluate right side of the assignment. To do that, we need first to perform the ++ operation, only then our variables on the right are ready to be added.
So what is operator ++ in this context? It is in turn a shorthand for a function, that does something similar to this:
function preIncrement(&$variable) {
$variable = $variable + 1;
return $variable;
}
Note that variable is a reference (&$variable, rather than $variable). What that means is that inside that function, if we modify variable, it will modify the variable that was passed to it, OUTSIDE. So when we pass $x, the function increases $x and then returns some number value. That number value is being replaced in the right side of the assignment.
So, when that line really looks like is:
$x = $x + postIncrement($x);
So, to evaluate we need to first execute the function in the assignment and get the functions return value. It happens to be 11. Great, now we know we need to add 11 to $x.
$x = $x + 11;
Great, lets just read current value of $x and we can assign. $x is 11. postIncrement function increased it to 11 when we executed it. So:
$x = 11 + 11;
So now, $x is 22.
Lets compare that to post incrementation:
$x+=$x++;
Unrolling += ...
$x = $x + $x++;
As before, we need to get return value of $x++ before we can evaluate. Post incrementation looks something like this:
function postIncrement(&$variable) {
$oldValue = $variable;
$variable = $variable + 1;
return $oldValue;
}
So it takes our $x, increases its value, but returns the original value. As a result, the $x++ gets evaluated as 10. Now we arrive at:
$x = $x + 10;
Ok, lets evaluate $x. $x is 11. Post increment increased it when we executed it. So:
$x = 11 + 10;
So $x is 21 in that case.
Hope this helps you.
It is not clear the logic behind this PHP code to give out the answer 19. How can the answer be 19? What is the logic?
$i=5;
$i +=$i++ + ++$i;
echo $i;
$i=5;
$i +=$i++ + ++$i;
^
Take value of $i as 5 then increment to 6
^
increment value of $i from 6 to 7, and use the 7
^
5 + 7 = 12
^ $i is already 7, because of the increments in the previous operations,
so add the 12 we've just calculated, giving 19
First, let's consider the following code:
<?php
$e = 0;
$e += ++$e;
echo $e;
Will the output be 2, or will it be 1?
One the second line, the right hand side of the equation ++$e; will increment the value of $e, making $e (temporarily) equal 1.
When the left hand side of the equation is run, $e equals 1 already, so 1 will be added the that value, so essentially, the line really says $e = 1 + 1.
<?php
$e = 0;
$e = 1 + 1;
echo $e;
When we do the same with the equation given earlier,
$i=5;
$i +=$i++ + ++$i;
echo $i;
The importance here is post and pre incrementing.
++i increments i and evaluates to the new value of i.
i++ evaluates to the old value of i, and increments i.
When $i += $i++ + ++$i; is calculated, on the Right Hand Side, ++$i (which will be 5) and $i++ (which will be 7).
$i += 5 + 7 (which becomes 7 + 5 + 7) means that $i will equal 19.
$i += $i++ + ++$i ;
$i = $i + ($i+1 + 1+$i);
19 = 7 + (5 + 7);