Гру 272011
 

Короткие переменные не более 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% скорости (вернее, сэкономите).

Гру 272011
 

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

Одна и таже операция присваивания (либо echo/print для вывода на экран) в зависимости от того, заключены ли переменные в кавычеки или нет, сильно влияет на скорость. В первом и втором вариантах добавлены пробелы, чтобы выравнять размер общего кода для парсинга.

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

Переменная $test содержит строку “1234567890”.

 

 

 

счетчик кол-во
вызовов
общее
в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%
Гру 262011
 

Fatal error: Trying to clone an uncloneable object of class mysqli

 

Причины

Интерпретатор PHP работает в режими совместимости с Zend Engine первой версии zend.ze1_compatibility_mode

 

Решение

Отключение режима совместимости с Zend Engine 1.

В php.ini изменить значение параметра

zend.ze1_compatibility_mode off
Либо через .htaccess, путем добавления строки:
php_flag zend.ze1_compatibility_mode off

Гру 252011
 

В чем разница между одинарной кавычкой (‘) и двойной кавычкой (“)?

Эту синтаксическую особенность можно продемонстрировать на примере

<?php
$var=10;
echo ‘1) Значение переменной: $var’;
echo ‘<br>’;
echo “2) Значение переменной: $var”;
?>

Даст результат:

1) Значение переменной: $var
2) Значение переменной: 10

 

Как видите, в первом случае PHP воспринял $var как текст, во втором – как имя переменной. Соответственно, на месте $var во втором случае мы увидели значение переменной $var, при чем если между двойными кавычками встречается символ $, обозначающий переменную, то PHP воcпримет следующий за ним набор символов (вплоть до первого символа, который не разрешен для имени переменной), как имя переменной. Если эта переменная не была объявлена, PHP сгенерирует ошибку.

Важная деталь: при двойных кавычках интерпретер не «всего-лишь» заменяет переменные и спецсимволы на их значение, а сначала ищет их во всём наборе символов от начала до конца. Так как при одинарных кавычках этого не происходит, то и обработка, соответственно, быстрей. При объёмных проектах разница во времени выполнения скрипта становится ощутимой.

Гру 252011
 

Генерирование уникальных ID

Могут возникать ситуации, когда вам нужно сгенерировать уникальную строку. Я видел множество людей, использовавших для этого функцию md5(), хотя она предназначена не совсем для этой цели:

1.// generate unique string
2.echo md5(time() . mt_rand(1,1000000));

В действительности существует функция PHP с названием uniqid(), которая для этого подходит абсолютно точно.

01.// generate unique string
02.echo uniqid();
03./* prints
04.4bd67c947233e
05.*/
06.
07.// generate another unique string
08.echo uniqid();
09./* prints
10.4bd67c9472340
11.*/

Можно заметить, что, хотя строки уникальны, они кажутся подобными из-за нескольких первых символов. Это оттого, что сгенерированная строка связана со временем сервера. Прекрасный побочный эффект, так как каждый заново сгенерированный id в дальнейшем следует в алфавитном порядке, так что их можно сортировать.

Чтобы уменьшить вероятность получения дубликатов, можно использовать префикс или второй параметр для увеличения энтропии:

01.// with prefix
02.echo uniqid('foo_');
03./* prints
04.foo_4bd67d6cd8b8f
05.*/
06.
07.// with more entropy
08.echo uniqid('',true);
09./* prints
10.4bd67d6cd8b926.12135106
11.*/
12.
13.// both
14.echo uniqid('bar_',true);
15./* prints
16.bar_4bd67da367b650.43684647
17.*/

Эта функция будет генерировать более короткие строки, чем md5(), что позволит сэкономить место.

 Posted by at 07:24  Tagged with: