What's the difference between ++$i and $i++ in PHP?

What's the difference between ++$i and $i++ in PHP?

++$i is pre-increment whilst $i++ post-increment.

• pre-increment: increment variable i first and then de-reference.
• post-increment: de-reference and then increment i

> "Take advantage of the fact that PHP > allows you to post-increment ($i++) > and pre-increment (++$i). The meaning > is the same as long as you are not > writing anything like $j = $i++, > however pre-incrementing is almost 10% > faster, which means that you should > switch from post- to pre-incrementing > when you have the opportunity, > especially in tight loops and > especially if you're pedantic about > micro-optimisations!"

• TuxRadar

For further clarification, post-incrementation in PHP has been documented as storing a temporary variable which attributes to this 10% overhead vs. pre-incrementation.

++$i increments $i, but evaluates to the value of $i+1 $i++ increments $i, but evaluates to the old value of $i.

Here's an example:

$i = 10;
$a = $i++;
// Now $a is 10, and $i is 11

$i = 10;
$a = ++$i;
// Now $a is 11, and $i is 11

There is sometimes a slight preformance cost for using $i++. See, when you do something like

$a = $i++;

You're really doing this:

$temporary_variable = $i;
$i=$i+1;
$a=$temporary_variable;

++$i is pre-incrementation

1. $i is incremented
2. the new value is returned

$i++ is post-incrementation

1. the value of $i copied to an internal temporary variable
2. $i is incremented
3. the internal copy of the old value of $i is returned

++$i //first increment $i then run line
$i++ //first run line then increment $i 

in this case there is no difference:

for($i = 0;$i<3;++$i)var_dump $i;
/*
int(0)
int(1)
int(2)
*/
for($i = 0;$i<3;$i++)var_dump $i;
/*
int(0)
int(1)
int(2)
*/

but:

for($i = 0;$i<3; $j = ++$i )var_dump($j);
/*
NULL
int(1)
int(2)
*/
for($i = 0;$i<3; $j = $i++ )var_dump($j);
/*
NULL
int(0)
int(1)
*/

this example elplains simply

<?php 

$x = 10;  

echo $x++. ' '.$x;  // the result is 10 and 11

echo '<br>';

$y = 10;

echo ++$y. ' ' .$y; // the result is 11 and 11

// so the  $x++ is not showing +1 at first but the next time
// and the ++y is showing +1 first time but not increasing next

Difference is: ++$i will increment $i variable and return updated value, while $i++ will return original value, so increment it.

$prefix = 1;
$postfix = 1;
echo ++$prefix;   // 2
echo $postfix++;  // 1

$i++ is known as post-increment. It increments the value of $i only after assigning the original value of $i to $j first.

++$i is known as pre-increment. It increments the value of $i before assigning the value to $j, so the updated value of $i will be assigned to $j.

Hence,

$i = 4;
$j = $i++;
// Now, $i = 5 and $j = 4

$i = 4;
$j = ++$i;
// Now, $i = 5 and $j = 5

These theories apply in a similar manner for decrementing as well.

Hope this helps!

To explain jldupont's point:

$i = 1;
$x = $i++;
echo $x; // prints 1
$x = ++$i;
echo $x; // prints 3

Another way of looking at pre and post incrementing is that it's shorthand for combining 2 statements.

Pre-incrementing

// long form
$y = $y + 1;
$x = $y; // any statement using $y

// shorthand
$x = ++$y; // the same statement using $y

Post-incrementing

// long form
$x = $y; // any statement using $y
$y = $y + 1;

// shorthand
$x = $y++; // the same statement using $y

It's probably best-illustrated by an example...

Post-increment:

$zero = 0;
$n = $zero++; //$n is zero

Pre-increment:

$zero = 0;
$n = ++$zero; //$n is one

Short answer:

• Prefix increases the value and returns the value increased
• Postfix increases the value and returns the value before it was increased
• Prefix is faster

Long answer: If you think a little about it, how you would implement those yourself, you will probably realize why prefix is faster. Truth to be told, postfix is actually (often) implemented using prefix:

const T T::operator ++ (int) // postfix
    {
    T orig(*this);
    ++(*this); // call prefix operator
    return (orig);
    }

Avoid postfix unless you have a specific reason not to. The difference in speed can be quite a lot for complex datatypes.

I actually looked this up a few days ago. Heres my source.

The main purpose of the post-fix increment operator is usage like this:

while(*condition*)
    $array[$i++] = $something;

This is a very elegant way, how to get around some array iterations. Breakdown:

1. Variable $something will be assigned to the array element indexed with $i
2. Variable $i will be incremented
3. Iteration is at the end, condition will be checked

In all other cases, you should use the prefix operator. It makes the code much more clear (You can be sure, that you already work with the incremented value of particular variable).

I ran the following code to test if ++$i is 10% faster than $i++. I admit, the code does not have a stable outcome but even then I should at least have seen some numbers near the 10%. The highest I got was 4-4.5% approximately.

<?php

$randomFloat = rand(0, 10) / 10;

$before1 = microtime(true);

for($i=0; $i <1000000; ++$i){
    $rand = (rand(0, 10) / 10) * (rand(0, 10) / 10);
}

$after1 = microtime(true);
echo 'it took '.($after1-$before1) . ' seconds fot ++$i<br />';

$before2 = microtime(true);

for($i=0; $i <1000000; $i++){
    $rand = (rand(0, 10) / 10) * (rand(0, 10) / 10);
}

$after2 = microtime(true);
echo 'it took '.($after2-$before2) . ' seconds fot $i++<br /><br />';

echo '++$i is '.((($after1-$before1)*100)/($after2-$before2)-100).'% faster than $i++';

Both operators still do what their syntax implies: to increment. Regardless of prefix or postfix, the variable is sure to be incremented by 1. The difference between the two lies in their return values.

1. The prefix increment returns the value of a variable after it has been incremented.

2. On the other hand, the more commonly used postfix increment returns the value of a variable before it has been incremented.

// Prefix increment

let prefix = 1;
console.log(++prefix); // 2

console.log(prefix); // 2

// Postfix increment

let postfix = 1;

console.log(postfix++); // 1

console.log(postfix); // 2

To remember this rule, I think about the syntax of the two. When one types in the prefix increment, one says ++x. The position of the ++ is important here. Saying ++x means to increment (++) first then return the value of x, thus we have ++x. The postfix increment works conversely. Saying x++ means to return the value of x first then increment (++) it after, thus x++.