I tried creating a reference to the variable ie
$var = & $this->var;

The speed tests were impressive.
At 1,000,000 iterations
This()
Start Time:1188316233.75
End Time:1188316234.3781
Total Time:0.62805891036987

Ref()
Start Time:1188316234.3781
End Time:1188316234.5309
Total Time:0.15274381637573

Regarding == vs ===, the identity check (===) actually will be doing less processing because it doesn’t have to cast variables to different types.

I did some benchmarking:

5,000,000 iterations
TESTS:
1.1: 1 == 1
1.2: 1 == ‘1′
1.3: 1 == 2
1.4: 1 == ‘a’
2.1: 1 === 1
2.2: 1 === ‘1′
2.3: 1 === 2
2.4: 1 === ‘a’

RESULTS:
1.1: 4.2496 (108.0435%)
1.2: 5.4232 (137.8819%)
1.3: 4.8647 (123.6827%)
1.4: 5.3762 (136.6878%)
2.1: 4.0064 (101.8609%)
2.2: 3.9332 (100%)
2.3: 3.9355 (100.059%)
2.4: 3.9373 (100.1045%)

so you can see that identity checking is much quicker.

I’m not posting on a Monday morning; I’m posting at 12:30 on a Saturday night and blame the goof on the fact that I’m looking up PHP optimizations on a Saturday night

for ($i=count($some_array);$i;){
–$i;
}

Is that the best way to this? Wouldn’t it be better to use a temporary variable instead of asking the for loop to count the array each time? It was mentioned earlier in the comments, but not-seeing it here makes me wonder if it was intentional, or just intending to show the decrement.

$temp = count($some_array);
for ($i=count($temp);$i;){
–$i;
}

Try Memcache for caching and xdebug for profiling, they both do their job very well.

(I’m sorry for the typos in my previous post … switching between languages in the early morning ;-))

it’s me again. Don’t had the time for know to test the difference between “==” and “===” but for now I believe the benchmark (even if really GOOD benchmarks are seldom, because most of them missing important points)

@Logan:

Yes, that’s clear. I think this post is intended to show everyone some small optimizations in the script language itselfs, nothing more.

It should be clear to everyone, that the real bottlenecks are elsewhere, so you can keep some simple rules:

1. use external resources wisely
2. do not code / use bloated code. Small code = fast code (in most cases ;))
3. include only the files that you really need
4. C code is faster than PHP code, so if you can solve the problem with an internal PHP function, do it!

and the most important rule:

5. Cache as much as possible!

alone the fifth point make way more sense than most of the code optimizations you can do … and it keeps your code read able.

SQL optimization is a good point to. If you work with MySQL I recommend you the book: “High performance MySQL” from Jeremy D. Zawodny

for ($i=0;isset($some_array[$i]);++$i){	
}

I found it is not as fast as

  $temp=count($some_array);
for ($i=0;$i

My test are from this code, on PHP5.2:

$some_array = range(0,100000);
 
    $timeparts = explode(' ',microtime());
  $starttime = $timeparts[1].substr($timeparts[0],1);
for ($i=0;isset($some_array[$i]);++$i){
 
 
}
  $timeparts = explode(' ',microtime());
  $endtime = $timeparts[1].substr($timeparts[0],1);
  echo bcsub($endtime,$starttime,6),'';
 
  $timeparts = explode(' ',microtime());
  $starttime = $timeparts[1].substr($timeparts[0],1);
  $temp=count($some_array);
for ($i=0;$i';

Also, in some cases, the array can be looped backwards. like this

for ($i=count($some_array);$i;){
--$i;
}

which is the fastest because compare to loop forward, one less conditional saved from every iteration.

If you would care to share some tips then please do. I might add SQL tips at a later stage.