Right now this page has a huge amount of attention by the international website programming community. Because of this I've had many many different opinions emailed to me about what people think about these results and how they were found.
Keep sending them in.
This project has been a long time dream for me and I'd love to keep on learning about what I'm doing right / wrong and how we should approach this topic. If you have any information / opinions that you would like to share (
especially about the larger bottleneck problems), please contact me via
my portfolio.
Chris Vincent
PHPBench.com was constructed as a way to open people's eyes to the fact that not every PHP code snippet will run at the same speed. You may be surprised at the results that this page generates, but that is ok. This page was also created so that you would be able to find discovery in these statistics and then maybe re-run these tests in your own server environment to play around with this idea yourself, by using the code examples (these code examples are automatically generated and as the code in my .php files change, so do they).
NOTE: You must keep in mind to refresh this page a few times to "catch" the right result. The numbers change sometimes drastically during each refresh. I assume that this is because of PHP's memory garbage collector that drops in randomly and also other processes that run on this machine have an influence.
NOTE: The microtime() method for testing out these tests has only been utilised for simplicities sake. If anything more advanced was used, those whom are just starting out on their PHP journey would have difficulties understanding.
Counting LoopsFor vs. While
Is there an actual difference between counting up between the for loop and the while loop?
+ 100 %
for($i = 0; $i < 1000000; ++$i);
Total time: 138076 µsview code
+ 111 %
$i = 0; while($i < 1000000) ++$i;
Total time: 153487 µsview code
Conclusion:
Well there you have it, the while loop 90% of the time is indeed slightly faster
Using the =&-ref-operator$obj = new SomeClass() vs. $obj =& new SomeClass()
Is a good idea to use the =&-ref-operator when creating a new object? Call 1'000x
+ 101 %
$obj = new SomeClass();
Total time: 1095 µsview code
+ 100 %
$obj =& new SomeClass();
Total time: 1082 µsview code
Conclusion:
There seams to be no difference in performance.
String Outputecho vs. print
Is a there a difference between what option you use to output your content?. Called within Output Buffering 1'000x
+ 146 %
echo 'aaaaaaaaaaaaaaaaaaaaaaaaaaaa'
Total time: 318 µsview code
+ 151 %
print 'aaaaaaaaaaaaaaaaaaaaaaaaaaaa'
Total time: 327 µsview code
+ 181 %
echo 'aaaaaaa'.'aaaaaaa'.'aaaaaaa'.'aaaaaaa'
Total time: 393 µsview code
+ 404 %
echo 'aaaaaaa','aaaaaaa','aaaaaaa','aaaaaaa'
Total time: 878 µsview code
+ 193 %
print 'aaaaaaa'.'aaaaaaa'.'aaaaaaa'.'aaaaaaa'
Total time: 419 µsview code
+ 591 %
$a = 'aaaaaaa';
echo 'aaaaaaa'.$a.'aaaaaaa'.$a
Total time: 1283 µsview code
+ 500 %
$a = 'aaaaaaa';
echo 'aaaaaaa',$a,'aaaaaaa',$a
Total time: 1086 µsview code
+ 583 %
$a = 'aaaaaaa';
print 'aaaaaaa'.$a.'aaaaaaa'.$a
Total time: 1266 µsview code
+ 625 %
$a = 'aaaaaaa';
echo $a.$a.$a.$a
Total time: 1357 µsview code
+ 516 %
$a = 'aaaaaaa';
echo $a,$a,$a,$a
Total time: 1120 µsview code
+ 628 %
$a = 'aaaaaaa';
print $a,$a,$a,$a
Total time: 1365 µsview code
Conclusion:
In reality the echo and print functions serve the exact purpose and therefore in the backend the exact same code applies. The one small thing to notice is that when using a comma to separate items whilst using the echo function, items run slightly faster.
Variable Type CheckingisSet() vs. empty() vs. is_array()
What is the performance of isSet() and empty(). Call 2'000x
+ 124 %
isSet() with var that was set
Total time: 588 µsview code
+ 143 %
empty() with var that was set
Total time: 676 µsview code
+ 104 %
isSet() with var that was *not* set
Total time: 494 µsview code
+ 108 %
empty() with var that was *not* set
Total time: 512 µsview code
+ 125 %
isSet() with array-var that was set
Total time: 594 µsview code
+ 140 %
empty() with array-var that was set
Total time: 663 µsview code
+ 100 %
isSet() with array-var that was *not* set
Total time: 474 µsview code
+ 100 %
empty() with array-var that was *not* set
Total time: 474 µsview code
+ 273 %
is_array() of an array
Total time: 1295 µsview code
+ 255 %
is_array() of a string
Total time: 1209 µsview code
+ 436 %
is_array() of a non set value
Total time: 2066 µsview code
+ 441 %
isSet() AND is_array() of a non set value
Total time: 2090 µsview code
Conclusion:
isSet() and empty() are identical. So alway check if val is set at all befor using type-checking. E.g. if (isSet($foo) AND is_array($foo))
Modify Loop:
foreach() vs. for vs. while(list() = each())
What would happen if we alter the reading loop test to test the results of a loop created to simply alter the data in each of the values in the array?
Given again is a Hash array with 100 elements, 24byte key and 10k data per entry.
+ 1148 %
foreach($aHash as $key=>$val) $aHash[$key] .= "a";
Total time: 1161 µsview code
+ 217 %
while(list($key) = each($aHash)) $aHash[$key] .= "a";
Total time: 220 µsview code
+ 100 %
$key = array_keys($aHash);
$size = sizeOf($key);
for ($i=0; $i<$size; $i++) $aHash[$key[$i]] .= "a";
Total time: 101 µsview code
Conclusion:
Proof in this example shows how functionally murderous the foreach() loop can be.
Control Structuresswitch/case/default vs. if/elseif/else
Is a there a difference between switch and if structures?. Call 1'000x
+ 147 %
if and elseif (using ==)
Total time: 424 µsview code
+ 150 %
if, elseif and else (using ==)
Total time: 431 µsview code
+ 107 %
if and elseif (using ===)
Total time: 308 µsview code
+ 100 %
if, elseif and else (using ===)
Total time: 288 µsview code
+ 142 %
switch / case
Total time: 410 µsview code
+ 150 %
switch / case / default
Total time: 431 µsview code
Conclusion:
Using a switch/case or if/elseif is almost the same. Note that the test is unsing === (is exactly equal to) and is slightly faster then using == (is equal to).
Using the =&-ref-operator$obj = $someClass->f() vs. $obj =& $someClass->f()
Is a good idea to use the =&-ref-operator when calling a function in an object? Call 1'000x
+ 100 %
$obj = $someClass->f();
Total time: 1035 µsview code
+ 196 %
$obj =& $someClass->f();
Total time: 2026 µsview code
Conclusion:
Unless your extremely worried about how much RAM your using, leaving the &-ref-operator out seems like the slightly faster option.
Using the &-ref-operator...as a so called "alias"
Is a good idea to use the &-ref-operator to substitute (or alias) a complex mutidim-array? . Call 1'000x
E.g. $person = &$aHach["country"]["zip"]["street"]["number"]["name"]
+ 211 %
$alias = $aSingleDimArray[$i]
Total time: 1255 µsview code
+ 100 %
$alias = &$aSingleDimArray[$i]
Total time: 596 µsview code
+ 239 %
$alias = $aMultiDimArray[$i]["aaaaa"]["aaaaaaaaaa"]
Total time: 1423 µsview code
+ 411 %
$alias = &$aMultiDimArray[$i]["aaaaa"]["aaaaaaaaaa"]
Total time: 2450 µsview code
+ 265 %
$alias = veryMultiDimArray[$i]["a"]["aa"]["aaa"]["aaaa"]["aaaaa"]
Total time: 1580 µsview code
+ 822 %
$alias = &$veryMultiDimArray[$i]["a"]["aa"]["aaa"]["aaaa"]["aaaaa"]
Total time: 4900 µsview code
Conclusion:
Whilst only using a one dimensional array, it's actually faster to use an alias, but anything larger will result in a performance drop.
Read Loop:foreach() vs. for() vs. while(list() = each())
What is the best way to loop a hash array?
Given is a Hash array with 100 elements, 24byte key and 10k data per entry
+ 100 %
foreach($aHash as $val);
Total time: 25 µsview code
+ 711 %
while(list(,$val) = each($aHash));
Total time: 178 µsview code
+ 128 %
foreach($aHash as $key => $val);
Total time: 32 µsview code
+ 810 %
while(list($key,$val) = each($aHash));
Total time: 203 µsview code
+ 248 %
foreach($aHash as $key=>$val) $tmp[] = $aHash[$key];
Total time: 62 µsview code
+ 887 %
while(list($key) = each($aHash)) $tmp[] = $aHash[$key];
Total time: 222 µsview code
+ 300 %
Get key-/ value-array: foreach($aHash as $key[]=>$val[]);
Total time: 75 µsview code
+ 303 %
Get key-/ value-array: array_keys() / array_values()
Total time: 76 µsview code
+ 400 %
$key = array_keys($aHash);
$size = sizeOf($key);
for ($i=0; $i<$size; $i++) $tmp[] = $aHash[$key[$i]];
Total time: 100 µsview code
Conclusion:
In all cases I've found that the foreach loop is substantially faster than both the while() and for() loop procedures. One thing to note is that when using an entire loop from the start it's extremely good to use the reset() function in all examples
Given that the previous version of the tests have been very controvercial and incorrect, I must appologise for forgetting to implement the reset() function to allow the while() loops to start from the beginning instead of the end. Thanks to Anthony Bush for spotting this out.
Quote Typesdouble (") vs. single (') quotes
Is a there a difference in using double (") and single (') quotes for strings. Call 1'000x
+ 101 %
single (') quotes. Just an empty string: $tmp[] = '';
Total time: 652 µsview code
+ 100 %
double (") quotes. Just an empty string: $tmp[] = "";
Total time: 643 µsview code
+ 115 %
single (') quotes. 20 bytes Text : $tmp[] = 'aaaaaaaaaaaaaaaaaaaa';
Total time: 737 µsview code
+ 108 %
double (") quotes. 20 bytes Text : $tmp[] = "aaaaaaaaaaaaaaaaaaaa";
Total time: 696 µsview code
+ 107 %
single (') quotes. 20 bytes Text and 3x a $ : $tmp[] = 'aa $ aaaa $ aaaa $ a';
Total time: 690 µsview code
+ 107 %
double (") quotes. 20 bytes Text and 3x a $ : $tmp[] = "aa $ aaaa $ aaaa $ a";
Total time: 691 µsview code
+ 108 %
double (") quotes. 20 bytes Text and 3x a \$ : $tmp[] = "aa \$ aaaa \$ aaaa \$ a";
Total time: 697 µsview code
Conclusion:
In today's versions of PHP it looks like this argument has been satisfied on both sides of the line. Lets all join together in harmony in this one!
Counting LoopsFor-loop test
Is it worth the effort to calculate the length of the loop in advance?
e.g. "for ($i=0; $i<$size; $i++)" instead of "for ($i=0; $i<sizeOf($x); $i++)"
A loop with 1000 keys with 1 byte values are given.
+ 100 %
With pre calc - count()
Total time: 405 µsview code
+ 48632 %
Without pre calc - count()
Total time: 196997 µsview code
+ 118 %
With pre calc - sizeof()
Total time: 476 µsview code
+ 54768 %
Without pre calc - sizeof()
Total time: 221852 µsview code
Conclusion:
Unsurprising results... this is one of the easiest things to implement in any application and is the widest agreed upon benchmarking item within the online PHP community. The results basically speak for themselves.