Выносите $переменные из "текстовых строк" - ускорение 25-40%

1. {$x="test".$test;    }
2. {$x="test $test";    }
3. {$x="test";$x.=$test;}

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max	общее время
test N1	1	3.5911	3.5911	00.0%	70.9%
test N2	1	5.0616	5.0616	40.9%	100.0%
test N3	1	4.9870	4.9870	38.9%	98.5%

Итак, никогда не пишите $a="$b", ибо это затормозит программу (в этой строке) на 40%.

Однако, если у вас большая строка, где много текста и переменных, различия в скорости уменьшаются, т.к. общие затраты на парсинг становятся намного больше, чем разные по эффективности команды. Но почему бы и не увеличить скорость программы (строк присваивания) почти на четверть таким простым методом?

1. {$x="test ".$test." test ".$test." test ".$test;                }
2. {$x="test $test test $test test $test";                         }
3. {$x="test ";$x.=$test;$x="test ";$x.=$test;$x="test ";$x.=$test;}

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max	общее время
test N1	1	7.6894	7.6894	00.0%	66.0%
test N2	1	9.5515	9.5515	24.2%	82.0%
test N3	1	11.6506	11.6506	51.5%	100.0%

Короткие переменные не более 7 символов - ускорение 15%

1. {$x=1;}
2. {$x2=1;}
3. {$x03=1;}
4. {$x004=1;}
5. {$x0005=1;}
6. {$x00006=1;}
7. {$x000007=1;}
8. {$x0000008=1;}
9. {$x000000010=1;}
10. {$x00000000012=1;}
11. {$x0000000000014=1;}
12. {$x000000000000016=1;}
13. {$x0000000000000000000000000000032=1;}

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max	общее время
test N1	1	1.7000	1.7000	00.0%	68.5%
test N2	1	1.7028	1.7028	00.2%	68.6%
test N3	1	1.7182	1.7182	01.1%	69.2%
test N4	1	1.7228	1.7228	01.3%	69.4%
test N5	1	1.7536	1.7536	03.2%	70.6%
test N6	1	1.7504	1.7504	03.0%	70.5%
test N7	1	1.7799	1.7799	04.7%	71.7%
test N8	1	1.9604	1.9604	15.3%	78.9%
test N9	1	1.9865	1.9865	16.9%	80.0%
test N10	1	2.0119	2.0119	18.3%	81.0%
test N11	1	2.0302	2.0302	19.4%	81.7%
test N12	1	2.1288	2.1288	25.2%	85.7%
test N13	1	2.4835	2.4835	46.1%	100.0%

Переменные от 32 символов могут тормознуть программу почти на половину.

Но если заполнять пробелами (" "), чтобы все строки "$x=1; ..." по длине занимали одно и тоже расстояние, то получается вот что:

1. {$x=1;                                   }
2. {$x2=1;                                  }
3. {$x03=1;                                 }
4. {$x004=1;                                }
5. {$x0005=1;                               }
6. {$x00006=1;                              }
7. {$x000007=1;                             }
8. {$x0000008=1;                            }
9. {$x000000010=1;                          }
10. {$x00000000012=1;                        }
11. {$x0000000000014=1;                      }
12. {$x000000000000016=1;                    }
13. {$x0000000000000000000000000000032=1;    }

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max	общее время
test N1	1	2.1167	2.1167	01.9%	83.3%
test N2	1	2.0766	2.0766	00.0%	81.7%
test N3	1	2.0937	2.0937	00.8%	82.4%
test N4	1	2.0821	2.0821	00.3%	81.9%
test N5	1	2.1145	2.1145	01.8%	83.2%
test N6	1	2.0921	2.0921	00.7%	82.3%
test N7	1	2.1076	2.1076	01.5%	82.9%
test N8	1	2.3058	2.3058	11.0%	90.7%
test N9	1	2.3046	2.3046	11.0%	90.7%
test N10	1	2.3107	2.3107	11.3%	90.9%
test N11	1	2.3111	2.3111	11.3%	90.9%
test N12	1	2.3680	2.3680	14.0%	93.2%
test N13	1	2.5418	2.5418	22.4%	100.0%

Уж как комментировать тест переменной из одного символа (на 2% медленне самого быстрого) - не знаю... Наверно, тесты имеют большую погрешность. Предлагаю кому-нибудь запустить тест на час (исходники теста внизу страницы).

Одно ясно - при длине переменных в 8 и более символов происходит резкое снижение производительности, до 15%! А команд, включающих названия переменных, очень много. Еще один менее резкий скачек на переменных с именем 16 символов в длину и более. А в остальных случаях - чем больше, тем дольше, весьма линейная зависимость.

Вывод - не используйте переменны из 8 и более символов, выиграете 15% скорости (вернее, сэкономите).

Тормозят ли массивы в PHP? Вернее, как именно. Ускорение 40%.

1. {$test[0000]=1;$test[0001]=1;$test[0002]=1;$test[0003]=1;$test[0004]=1;     }
2. {$test[1000]=1;$test[1001]=1;$test[1002]=1;$test[1003]=1;$test[1004]=1;     }
3. {$test["aa"]=1;$test["bb"]=1;$test["cc"]=1;$test["dd"]=1;$test["ee"]=1;     }
4. {$test[aa]=1;  $test[bb]=1;  $test[cc]=1;  $test[dd]=1;  $test[ee]=1;       }
5. {$test[0][0]=1;$test[0][1]=1;$test[0][2]=1;$test[0][3]=1;$test[0][4]=1;     }
6. {$test[2][1]=1;$test[3][8]=1;$test[4][9]=1;$test[33][99]=1;$test[123][99]=1;}
7. {$test[a][b]=1;$test[x][y]=1;$test[d][c]=1;$test[a][s]=1;$test[b][n]=1;     }

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max	общее время
test N1	1	5.3924	5.3924	01.1%	28.0%
test N2	1	5.3332	5.3332	00.0%	27.7%
test N3	1	5.7651	5.7651	08.1%	29.9%
test N4	1	7.6543	7.6543	43.5%	39.7%
test N5	1	6.6649	6.6649	25.0%	34.6%
test N6	1	6.6221	6.6221	24.2%	34.3%
test N7	1	19.2820	19.2820	261.5%	100.0%

Что тут можно комментировать.. все очевидно. Доступ к элементу одномерного ассоциативного массива по имени, не заключенному в кавычки, тормозит процесс на треть (относительно того же примера, но в кавычках). А вот в двухмерном массиве программа работает медленне аж в 2.5 раза! После такого теста хочешь не хочешь, а в любой программе пожертвуешь удобством - обращение к элементам массива по имени без кавычек.

Выносите многомерные массивы из "текстовых строк" - ускорение 25-30%. Одномерные можно не выносить.

1. {$x="test ".$myarray["name"]["second"][1]." test";       }
2. {$x="test {$myarray[name][second][1]} test";             }
3. {$x="test ";$x.=$myarray["name"]["second"][1];$x=" test";}

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max	общее время
test N1	1	3.5369	3.5369	00.0%	69.9%
test N2	1	5.0605	5.0605	43.1%	100.0%
test N3	1	4.6017	4.6017	30.1%	90.9%

Тот же пример с ассоциативным 3-х мерным массивом, но с обращением к элементу по его индексному номеру:

1. {$x="test ".$myarray[3][2][0]." test";       }
2. {$x="test {$myarray[3][2][0]} test";         }
3. {$x="test ";$x.=$myarray[3][2][0];$x=" test";}

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max	общее время
test N1	1	3.3012	3.3012	00.0%	73.1%
test N2	1	4.1667	4.1667	26.2%	92.3%
test N3	1	4.5145	4.5145	36.8%	100.0%

Разница в 1 и 2 вариантах очень мала. Это говорит, что потери на не эффективное использование кавычек не слишком большое, чем доступ к массивам (см. тесты в первой главе).

1. {$x="test".$myarray["test"]."test";}
2. {$x="test$myarray[test]test";      }
3. {$x="test{$myarray[test]}test";    }

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max	общее время
test N1	1	2.8495	2.8495	00.0%	80.9%
test N2	1	2.9519	2.9519	03.6%	83.9%
test N3	1	3.5202	3.5202	23.5%	100.0%

А теперь, на основании всех трех тестов, однозначный вывод: использовать фигурные скобки для обозначения границ имени элемента многомерного массива НЕЛЬЗЯ. Это сильно снижает скорость работы - 25-30% (в третьем варианте от простого добавления скобок скорость понизилась на четверть). Не использовать скобки нельзя. Следовательно, единственный способ не терять 30% скорости - выносить многомерные массивы из скобок.

Такой же тест, но для одномерных:

1. {$x="test".$myarray["test"]."test".$myarray["test"]."test".$myarray["test"];   }
2. {$x="test$myarray[test]testtest$myarray[test]testtest$myarray[test]test";      }
3. {$x="test{$myarray[test]}testtest{$myarray[test]}testtest{$myarray[test]}test";}

счетчик	кол-во вызовов	общее вpемя	сpеднее вpемя	% от min	% от max	общее время
test N1	1	6.5843	6.5843	00.0%	78.0%
test N2	1	6.7770	6.7770	02.9%	80.3%
test N3	1	8.4406	8.4406	28.2%	100.0%

Сравнивая два последних теста очевидно, что одномерные массивы можно и не выносить, потери всего 3-4% ( а вот на простых переменных - потери 25-40%!).