Trivia: incrementing $i

[HarryF]

Here's a little piece of PHP trivia;

In PHP there are basically three main ways to increment a variable by one. Using addition your options are;

$i=$i+1; 

$i++; 

++$i; 

Now running a little performance check;

<?php

function getmicrotime(){ 

    list($usec, $sec) = explode(" ",microtime()); 

    return ((float)$usec + (float)$sec); 

}





$start = getmicrotime();

$i=0;

while ($i < 1000000) {

    $i=$i+1;

}

$end = getmicrotime() - $start;

echo ( "<p>\$i=\$i+1 Took: ".$end );



$start = getmicrotime();

$i=0;

while ($i < 1000000) {

    $i++;

}

$end = getmicrotime() - $start;

echo ( "<p>\$i++ Took: ".$end );



$start = getmicrotime();

$i=0;

while ($i < 1000000) {

    ++$i;

}

$end = getmicrotime() - $start;

echo ( "<p>++\$i Took: ".$end );



?>

The results are;

$i=$i+1 Took: 4.1503800153732

$i++ Took: 2.8252899646759

++$i Took: 2.7342989444733

++$i is consistently slightly faster than $i++. In most cases (not all), ++$i can be used interchangeably with $i++.

Head here for more detail: http://www.php.net/manual/en/languag....increment.php

OK - trivia over.

Finally a brain teazer (don't give the game away by answering here);

$i=1;

$i += ++$i + $i++;

echo ($i); 

What will PHP echo at the end (without running the code first)?

[dragonhawk]

Pick me!! Pick me!!!

Very interesting about the $i++ and the ++$i

I always use $i++ without thinking anything of it...

[Jeremy W.]

++i is always faster in every programming language

[pippo]

Harry,
you forget this case

$i += 1; 

using your script I have

$i=$i+1 Took: 4.01947200298

$i++ Took: 2.70495903492

++$i Took: 2.622205019

$i += 1 Took: 2.75653505325

It could be interesting to do an average of the times,
scoates did something similar if I'm right


pippo

[Agent Dwarf]

Did you know that the ++ operator works on numbers AND strings? a will turn to b, z will turn to aa. Pretty useful.

[Hierophant]

Hmmm... Well no one answered the brain teaser.

I mostly use $i++, I would think most people do. It actually looks the most logical. However once in a while it is necessary to increment a variable after using it somewhere so ++$i comes in handy as well.

[Agent Dwarf]

I'll make an educated guess and say 10.

Edit:

[siteguru]

My guess was wrong too

Back to elementary math for me I guess.

[HarryF]

It's a tricky one. And apparently if you try it with different programming languages, you'll get different answers!

[pippo]

>>> What will PHP echo at the end
6

*edited*
I launched it...but I have to admit that I was wrong...

*edited 2*
In C the result is the same as in php:

i = 1;
i += ++i + i++;

[Mincer]

Originally posted by HarryF
It's a tricky one. And apparently if you try it with different programming languages, you'll get different answers!

It's because some languages have different operator precedence.

In case people don't understand the difference between $i++ and ++$i:

++$i is the pre-increment operator, and $i++ is the post-increment operator. To illustrate the difference, I'll use a simple example:

$i = 1 ;

print $i++ . ' - ' . $i ; 

This will print:

1 - 2

Whereas this:

$i = 1 ;

print ++$i . ' - ' . $i ; 

Will print:

2 - 2

As you can see, the pre-increment operator increments the variable before passing to the current pending function (in this case 'print'), the post-increment operator passes the variable, and then increments.

I hope that's reasonably clear.

Matt.

[samsm]

I found it very interesting that:

$i += 1; 

Was faster than

$i = $i +1; 

This suggests to me that:

$i .= $k; 

might be faster than

$i = $i . $k; 

and so on.

Does this basic theory hold up across most operations? (The fewer times you reference a variable, the faster it'll be.)

[HarryF]

Does this basic theory hold up across most operations? (The fewer times you reference a variable, the faster it'll be.)

Pretty much. Think the more instances of a variable PHP has to hold in memory, the slower it gets.

I could be wrong in saying this but perhaps it's worth thinking about the = operator as meaning "creates new instance of". So $i = $i + 1; creates another instance of $i.

As a matter of intest, that teazer in Java;

// MyI.java

import java.util.*;



public class MyI {

    

    private int i;



    void display () {

            this.i=1;

            this.i += ++this.i + this.i++;

            System.out.println("MyI: "+this.i);

    }



    public static void main ( String[] args ) {

        MyI m = new MyI();

        m.display();

    }

} 

Java gives 5 as the answer.

[pootergeist]

To go even faster (programming theory ergo untested) you could evaluate toward zero rather than toward 1000000.

$i = 1000000;
while($i>0) {
--$i;
}

No math is really involved to determine how far $i is from zero as it is always $i so it should beat determining if $i is less than a million. It certainly would be useful when used in a syntax where the million was variable

$i = $variable;
while(--$i>0) {
//stuff
}

as $variable doesn't need to be deduced each time.

Subnote: I guessed 6 too

[randem]

Originally posted by pootergeist
Subnote: I guessed 6 too

Since I haven't seen anyone point it out, I think someone should explain why it's not 6.

++$i is a preincrement, which means increment the value in $i before evaluating it.

$i++ is a postincrement, which means increment the value in $i after evaluating it.

So, for instance

$i = 1;
print $i++;

should print 1, and then leave a value of 2 in $i

[Mincer]

Originally posted by randem
Since I haven't seen anyone point it out, I think someone should explain why it's not 6.

*cough* see my previous post *cough*

[randem]

Originally posted by Mincer
*cough* see my previous post *cough*

Oops. Hahaha.

[Michel V]

Now, that's interesting:

$ perl

$i = 1;
$i += ++$i + $i++;
print $i;

8

So PHP says '7', Java says '5', Perl says '8', and I had guessed '6'. Phew!