Циклы: for, foreach, while, count/sizeof() - ускорение 15%-30%

В начале программы создается массив $test из целых чисел (100 000 элементов). Потом один раз запускаются приведенные ниже примеры. Цикл проходит данный массив 3-мя способами (разными циклами) и выполняет кое-какие операции. Не выполнять в цикле ничего нельзя ибо это будет уже совсем нереальный тест.

{$x=0; foreach($test as $n)                          { $x=sprintf("test%08i",$i);        }}
{$x=0; for ($it=0; $it<100000; $it++)                { $x=sprintf("test%08i",$i);        }}
{$x=0; $it=0; while($it<100000)                      { $x=sprintf("test%08i",$i); $it++; }}
{$x=0; for ($it=0; $it<count($test); $it++)          { $x=sprintf("test%08i",$i);        }}
{$x=0; $it=0; while($it<count($test))                { $x=sprintf("test%08i",$i); $it++; }}
{$x=0; $co=count($test); for ($it=0; $it<$co; $it++) { $x=sprintf("test%08i",$i);        }}
{$x=0; $co=count($test); $it=0; while($it<$co)       { $x=sprintf("test%08i",$i); $it++; }}
счетчик кол-во
вызовов общее
вpемя сpеднее
вpемя % от min % от max общее
время 
test N1 1 12.0313 12.0313 154.4% 100.0% 

 
test N2 1 4.7290 4.7290 00.0% 39.3% 

 
test N3 1 4.7712 4.7712 00.9% 39.7% 

 
test N4 1 10.2847 10.2847 117.5% 85.5% 

 
test N5 1 10.3466 10.3466 118.8% 86.0% 

 
test N6 1 9.1271 9.1271 93.0% 75.9% 

 
test N7 1 9.1409 9.1409 93.3% 76.0% 

Почему sprintf, а не реальное echo? echo использовать нельзя т.к. от него будет очень большой буфер (OUTPUT в браузер или консоль).

Теперь о деле. Бесспорный вывод - использование foreach сильно тормозит дело, а между for и while большой разницы нет. (На голом тесте for/while/foreach {..} тормоза foreach - 30%). Это не удивительно, т.к. foreach делает копию массива, на что тратиться масса времени (хотя это только слухи).

Вывод о не ассоциативных массивах: 1) foreach существенно замедляет работу 2) использование count() в простых циклах - замедленение 10%. Но на сложных циклах потери от лишних запусков count() будут абсолютно незаметны, так что ситуация не очевидна.

Сравнение count() и sizeof().

Судя по данным руководства - это алиасы. Об этом написано на страницах самих функций и дополнительной странице "Appendex => Aliases list". Что же мы видим на массиве в 100000 элементов:

{$x=0; for ($it=0; $it<count($test); $it++)  { $x=sprintf("test%08i",$test[$it]);}}
{$x=0; for ($it=0; $it<sizeof($test); $it++) { $x=sprintf("test%08i",$test[$it]);}}
счетчик кол-во
вызовов общее
вpемя сpеднее
вpемя % от min % от max общее
время 
test N1 1 3.0087 3.0087 15.7% 100.0% 

 
test N2 1 2.5998 2.5998 00.0% 86.4% 

Пусть тесты будут иметь погрешности... Но результат один - count() заметно отстает по скорости от sizeof()! Хм, я бы к записи в руководстве сделал приписку: "The sizeof() function is an alias for count(), but the last is very slow!"

Если кол-во элементов в массиве меньше 65000 (64К), то эти функции по скорости практически не различимы. Тут вывод простой - переходим на использование sizeof(), как ускоренного алиаса count(). Это принесет свои результаты на огромных массивах.

Ассоциативные массивы: тестирование разных способов перебора

С ними наблюдается такая же проблема: на разных по величине массивах разные функции эффективны, но лучше всех foreach!

Массив в 200 элементов и 1000 повторов программы:

{$x=0; foreach($test as $k=>$v) { $x=sprintf("%s=>%s ",$k,$v);                                                           }}
{$x=0; reset($test); while (list($k, $v) = each($test)) { $x=sprintf("%s=>%s ",$k,$v);                                   }}
{$x=0; $k=array_keys($test); $co=sizeof($k); for ($it=0; $it<$co; $it++) { $x=sprintf("%s=>%s ",$k[$it],$test[$k[$it]]); }}
{$x=0; reset($test); while ($k=key($test)) { $x=sprintf("%s=>%s ",$k,current($test)); next($test);                       }}
счетчик кол-во
вызовов общее
вpемя сpеднее
вpемя % от min % от max общее
время 
test N1 1 8.1222 8.1222 00.0% 78.7% 

 
test N2 1 10.3221 10.3221 27.1% 100.0% 

 
test N3 1 9.7921 9.7921 20.6% 94.9% 

 
test N4 1 8.9711 8.9711 10.5% 86.9% 

Тоже самое, но массив в 5000 элементов и 200 повторов:
счетчик кол-во
вызовов общее
вpемя сpеднее
вpемя % от min % от max общее
время 
test N1 1 14.4473 14.4473 00.0% 67.2% 

 
test N2 1 18.6801 18.6801 29.3% 86.9% 

 
test N3 1 21.5056 21.5056 48.9% 100.0% 

 
test N4 1 15.8514 15.8514 09.7% 73.7% 

Опять тоже самое, но массив в 100 000 элементов и без повторов:

счетчик кол-во
вызовов общее
вpемя сpеднее
вpемя % от min % от max общее
время 
test N1 1 3.5116 3.5116 00.0% 82.8% 

 
test N2 1 3.9724 3.9724 13.1% 93.6% 

 
test N3 1 4.2436 4.2436 20.8% 100.0% 

 
test N4 1 4.0026 4.0026 14.0% 94.3% 

Другие тесты на холостых циклах тоже показывают преимущество foreach.

Резюме:
sizeof() лучше, чем count()
в циклах sizeof лучше вообще заменить на переменную
for и while практически не отличимы
для перебора простых индексных массивов нужно использовать for или while
для перебора ассоциативных массивов нужно использотьва foreach

Для чтения файла file() быстрее, чем fopen+цикл - ускорение 40%

Чтобы прочитать в массив $x файл размером 1Мб (100 000 строк по 10 байт) можно воспользоваться двумя вариантами: чтение файла с помощью file(), либо традиционным методом fopen/fgets. Разумеется, для файлов разного объема и содержимого скорость может меняться. Но в данном примере статистика такова: file("1Mb_file.txt") работает на 40% быстрее, чем:

   $f=fopen("1Mb_file.txt","r") or die(1);
   while($x[]=fgets($f,1000));
   fclose($f);

Аналогичные варианты:

   $f=fopen("1Mb_file.txt","r") or die(1);
   while($s=fgets($f,1000)) $x[]=$s;
   fclose($f);

или

   $f=fopen("1Mb_file.txt","r") or die(1);
   while(!feof($f))) $x[]=fgets($f,1000);
   fclose($f);

работают еще медленнее (во втором случае лишняя функция feof() заметно снижает скорость). Тот же тест, но на 15Мб файле (100 000 строк по 150 байт) показывает разницу в 50%, в пользу file(). Тест проводился так, чтобы исключить фоновый своппинг во время работы из-за предшествующих команд создания/чтения таких больших файлов. Подсчитать тоже самое на очень маленьких файлах в 1-2 Кб не представляется возможным, т.к. операцию чтения нельзя повторять в течении одного теста, операции чтения будут кешироваться...