Сборник советов и фактов по оптимизации PHP-скриптов

    image Эту статью давно стоило переписать (слишком много «экономии на спичках»), но руки не доходят. Пускай весит и напоминает о том, как мы глупы в молодости.
    Одним из основных критериев успешности любого интернет-ресурса является скорость его работы и с каждым годом пользователи становятся всё более и более требовательными по этому критерию. Оптимизация работы php-скиптов — это один из методов обеспечения скорости работы системы.
    В этой статье я бы хотел представить на суд общественности свой сборник советов и фактов по оптимизации скриптов. Сборник собирался мною достаточно долго, основан на нескольких источниках и личных экспериментах.
    Почему сборник советов и фактов, а не жестких правил? Потому что, как я убедился, не существует «абсолютно правильной оптимизации». Многие приёмы и правила противоречивы и выполнить их все невозможно. Приходиться выбирать совокупность методов, которыми приемлемо пользоваться без ущерба безопасности и удобности. Я занял рекомендательную позицию и поэтому у меня советы и факты, которые Вы можете соблюдать, а можете и не соблюдать.
    Что бы не было путаницы, я разделил все советы и факты на 3 группы:
    • Оптимизация на уровне логики и организации приложения
    • Оптимизация кода
    • Бесполезная оптимизация

    Группы выделены условно и некоторые пункты можно отнести сразу к нескольким из них. Цифры приведены для среднестатистического сервера (LAMP). В статье не рассматриваются вопросы связанные с эффективностью различных сторонних технологий и фреймворков, так как это тема отдельных дискуссий.

    Оптимизация на уровне логики и организации приложения


    Многие из советов и фактов, относящихся к данной группе оптимизации, являются весьма значимыми и дают весьма большой выигрыш во времени.
    • Постоянно профилируйте свой код на сервере (xdebug) и на клиенте (firebug), что бы выявить узкие места кода
      Следует отметить, что профилировать надо и серверную, и клиентскую часть, так как не все серверные ошибки можно обнаружить на самом сервере.
    • Количество, используемых в программе пользовательских функций, никак не влияет на скорость
      Это позволяет использовать в программе бесчисленное число пользовательских функций.
    • Активно используйте пользовательские функций
      Положительный эффект достигается за счёт того, что внутри функций операции ведутся только с локальными переменными. Эффект этого больше, чем расходы на вызовы пользовательских функций.
    • «Критически тяжёлые» функции желательно реализовать на стороннем языка программирования в виде расширения PHP
      Это требует навыков программирования на стороннем языке, что значительно увеличивает время разработки, но в тоже время позволяет использовать приёмы вне возможности PHP.
    • Обработка статического файла html быстрее, чем интерпретируемого файла php
      Различие повремени на клиенте может составлять около 1 секунды, поэтому имеет смысл четкое разделение статики и генерируемых средствами PHP страниц.
    • Размер обрабатываемого (подключаемого) файла влияет на скорость
      Примерно на обработку каждых 2 Кб тратиться 0.001 секунды. Этот факт толкает нас на проведение минимизации кода скриптов при перенесении на рабочий сервер.
    • Старайтесь не использовать постоянно require_once или include_once
      Эти функции нужно использовать при наличии возможности повторного считывания файла, в остальных случаях желательно использовать require и include.
    • При ветвлении алгоритма, если имеются конструкции, которые могут не обрабатываться и их объём порядка 4 Кб и более, то более оптимально их подключать при помощи include.
    • Желательно использовать проверку отправляемых данных на клиенте
      Это вызвано тем, что при проверке данных на стороне клиента, резко снижается количество запросов с неверными данными. Системы проверки данных на клиенте строятся в основном с использованием JS и жестких элементов формы (select).
    • Желательно большие конструкций DOM для массивов данных строить на клиенте
      Это очень эффективный метод оптимизации при работе с отображением большого объёма данных. Суть его сводится к следующему: на сервере подготавливается массив данных и передаётся клиенту, а построение конструкций DOM предоставляется JS функциям. В результате нагрузка частично перераспределяется с сервера на клиент.
    • Системы, построенные на технологии AJAX, значительно быстрее, чем системы, не использующие эту технологию
      Это вызвано уменьшением объёмов вывода и перераспределением нагрузки на клиента. На практике скорость систем с AJAX в 2-3 раза выше. Замечание: AJAX в свою очередь создаёт ряд ограничений на использование других методов оптимизации, например, работа с буфером.
    • При получение post-запроса всегда возвращайте что-нибудь, можно даже пробел
      Иначе клиенту будет отправлена страница ошибки, которая весит несколько килобайт. Данная ошибка очень часто встречается в системах, использующих технологию AJAX.
    • Получение данных из файла быстрее, чем из БД
      Это во многом вызвано затратами на подключение к БД. К моему удивлению, огромный процент программистов маниакально хранят все данные в БД, даже когда использование файлов быстрее и удобнее. Замечание: в файлах можно хранить данные, по которым не ведётся поиск, в противном случае следует использовать БД.
    • Не осуществляйте подключение к БД без необходимости
      По неизвестной мне причине, многие программисты осуществляют подключение к БД на этапе считывания настроек, хотя далее они могут не делать запросов к БД. Это вредная привычка, которая стоит в среднем 0.002 секунды.
    • Используйте постоянное соединение с БД при малом количестве одновременно активных клиентов
      Выгода во времени вызвана отсутствием затрат на подключение к БД. Разница во времени примерно 0.002 секунды. Замечание: при большом количестве пользователей постоянные соединения использовать нежелательно. При работе с постоянными соединениями должен быть механизм завершения соединений.
    • Использование сложных запросов к БД быстрее, чем использование нескольких простых
      Разница во времени зависит от многих факторов (объём данных, настройка БД и пр.) и измеряется тысячными, а иногда даже сотыми, секунды.
    • Использование вычислений на стороне СУБД быстрее, чем вычисления на стороне PHP для данных хранящихся в БД
      Это вызвано тем фактором, что для таких вычислений на стороне PHP требуется два запроса к БД (получение и изменение данных). Разница во времени зависит от многих факторов (объём данных, настройка БД и пр.) и измеряется тысячными и сотыми секунды.
    • Если данные выборки из БД редко меняются и к этим данным обращается множество пользователей, то имеет смысл сохранить данные выборки в файл
      Например можно использовать следующий простой подход: получаем данные выборки из БД и сохраняем их как сериализованный массив в файл, далее любой пользователь использует данные из файла. На практике такой метод оптимизации может дать многократный прирост скорости выполнения скрипта. Замечание: При использовании данного метода требуются писать инструменты для формирования и изменения данных хранимых файле.
    • Кэшируйте данные, которые редко меняются, при помощи memcached
      Выигрыш времени может быть весьма значительным. Замечание: кэширование эффективно для статичных данных, для динамичных данных эффект снижается и может быть отрицательным.
    • Работа без объектов (без ООП) быстрее, чем работа с использованием объектов, примерно, в три раза
      Памяти «съедается» также больше. К сожалению, интерпретатор PHP не может работать с ООП также быстро как с обычными функциями.
    • Чем больше мерность массивов, тем медленнее они работают
      Потеря времени возникает из-за обработки вложенности структур.

    Оптимизация кода


    Данные советы и факты дают незначительны по сравнению с предыдущей группой прирост скорости, но в своей совокупности эти приёмы могут дать неплохой выигрыш времени.
    • echo и print значительно быстрее, чем printf
      Разница во времени может доходить до нескольких тысячных секунды. Это вызвано тем, что printf служит для вывода форматированных данных и интерпретатор проверяет полностью строку на вхождение таких данных. printf используется только для вывода данных, которым нужно форматирование.
    • echo $var."text" быстрее, чем echo "$var text"
      Это вызвано тем, что движок PHP во втором случае вынужден искать переменные внутри строки. Для больших объёмов данных и старых версий PHP различия по времени заметны.
    • echo 'a' быстрее, чем echo "a" для строк без переменных
      Это вызвано тем, что во втором случае движок PHP пытается найти переменные. Для больших объёмов данных различия во времени достаточно заметны.
    • echo 'a','b' быстрее, чем echo 'a'.'b'
      Вывод данных через запятую быстрее, чем через точку. Это вызвано тем, что во втором случае происходит конкатенация строк. Для больших объёмов данных различия во времени достаточно заметны. Примечание: это работает только с функцией echo, которая может принимать несколько строк в качестве аргументов.
    • $return='a'; $return.='b'; echo $return; быстрее, чем echo 'a'; echo 'b';
      Причина в том, что вывод данных требует некоторых дополнительных операций. Для больших объёмов данных различия во времени достаточно заметны.
    • ob_start(); echo 'a'; echo 'b'; ob_end_flush(); быстрее, чем $return='a'; $return.='b'; echo $return;
      Это вызвано тем, что вся работа осуществляется без обращения к переменным. Для больших объёмов данных различия во времени достаточно заметны. Замечание: данный прием неэффективен, если вы работаете с AJAX, так как в этом случае данные желательно возвращать в виде одной строки.
    • Используйте «профессиональную вставку» или ?> a b <?php быстрее, чем <?php echo 'a'; echo 'b'; ?>
      Статические данные (вне программного кода) обрабатываются быстрее, чем вывод данных PHP. Этот прием называется профессиональной вставкой. Для больших объёмов данных различия во времени достаточно заметны.
    • readfile быстрее, чем file_get_contents, file_get_contents быстрее, чем require, а require быстрее, чем include для вывода статического контента из отдельного файла
      По времени считывания пустого файла колебания от 0.001 для readfile до 0.002 для include.
    • require быстрее, чем include для интерпретируемых файлов
      Замечание: при ветвлении алгоритма, когда есть возможность не использовать интерпретируемый файл, надо использовать include, т.к. require подключает файл всегда.
    • if (...) {...} else if (...) {} быстрее, чем switch
      Время зависит от количества веток.
    • if (...) {...} else if (...) {} быстрее, чем if (...) {...}; if (...) {};
      Время зависит от количества веток и условий. Необходимо использовать else if везде, где это возможно, так как это самая быстрая «условная» конструкция.
    • Наиболее часто встречающиеся условия конструкции if (...) {...} else if (...) {} надо помещать в начале ветвления
      Интерпритатор просматривает конструкцию сверху вниз, пока не найдет выполнение условия. Если интерпретатор находит выполнение условия, то остальныю часть конструкции он не просматривает.
    • x = sizeOf($array); for($i = 0; $i < x; ++$i) {...} быстрее, чем for($i = 0; $i < sizeOf($array); ++$i) {...}
      Это вызвано тем, что во втором случае операция sizeOf будет выполнятся при каждой итерации. Время разницы выполнения зависит от числа элементов массива.
    • x = sizeOf($array); for($i = 0; $i < x; ++$i) {...} быстрее, чем foreach($arr as $value) {...} для не ассоциативных массивов
      Разница во времени значительна и увеличивается при увеличении массива.
    • preg _replace быстрее, чем ereg_replace, str_replace быстрее, чем preg_replace, но strtr быстрее, чем str_replace
      Разница во времени зависит от объёма данных и может достигать нескольких тысячных секунд.
    • Функции работы со строками быстрее, чем регулярные выражения
      Это правило является следствием предыдущего.
    • Удаляйте уже ненужные переменные-массивы для освобождения памяти.
    • Старайтесь не использовать подавление ошибок @
      Подавление ошибок производит ряд очень медленных операций, а так как частота повтора может быть очень большой, потери скорости могут быть значительными.
    • if (isset($str{5})) {...} быстрее, чем if (strlen($str)>4){...}
      Это вызвано тем, что вместо функции для работы со строками strlen используется стандартная операция проверки isset.
    • 0.5 быстрее, чем 1/2
      Причина в том, что во втором случае выполняется операция деления.
    • return быстрее, чем global при возвращении значения переменной из функции
      Это вызвано тем, что во втором случае создаётся глобальная переменная.
    • $row['id'] быстрее, чем $row[id]
      Первый вариант быстрее в 7 раз.
    • $_SERVER[’REQUEST_TIME’] быстрее, чем time() для определения времени запуска скрипта
      Причина в том, что в первом случае нет использования функции.
    • if ($var===null) {...} быстрее, чем if (is_null($var)) {...}
      Причина в том, что в первом случае нет использования функции.
    • ++i быстрее, чем i++, --i быстрее, чем i--
      Это вызвано особенностями ядра PHP. Разница по времени менее 0.000001, но если у Вас данные процедуры повторяются тысячи раз, то присмотритесь к данной оптимизации.
    • Инкремент инициализированной переменой i=0; ++i; быстрее, чем не инициализированной ++i
      Разница по времени около 0.000001 секунды, но из-за возможной частоты повтора следует помнить данный факт.
    • Использование «отработавших» переменных быстрее, чем объявление новых
      Или перефразирую иначе – Не создавайте лишних переменных.
    • Работа с локальными переменными быстрее, чем с глобальными, примерно, в 2 раза
      Хоть и разница во времени менее 0.000001 секунды, но из-за высокой частоты повторения следует стараться работать с локальными переменными.
    • Обращение к переменной напрямую быстрее, чем вызов функции, внутри которой определяется эта переменная в несколько раз
      На вызов функции тратиться примерно в три раза больше времени, чем на вызов переменной.

    Бесполезная оптимизация


    Ряд методов оптимизации на практике не оказывают большого влияния на скорость выполнения скриптов (выигрыш времени менее 0.000001 секунды). Несмотря на это, такая оптимизация зачастую становиться предметом споров. Я привел данные «бесполезные» факты для того, чтобы вы в последующим не уделяли им особого внимания при написании кода.
    • echo быстрее, чем print
    • include('абсолютный путь') быстрее, чем include('относительный путь')
    • sizeOf быстрее, чем count
    • foreach ($arr as $key => $value) {...} быстрее, чем reset ($arr); while (list($key, $value) = each ($arr)) {...} для ассоциативных массивов
    • Не комментированный код быстрее, чем комментированный, так как уходит дополнительное время на чтение файла
      Весьма глупо уменьшать объём комментариев ради оптимизации, надо просто в рабочих («боевых») скриптах проводить минимизацию.
    • Переменные с короткими названиями быстрее, чем переменные с длинными названиями
      Это вызвано сокращением объёмов обрабатываемого кода. Аналогично предыдущему пункту, надо просто в рабочих («боевых») скриптах проводить минимизацию.
    • Разметка кода с использованием табуляции быстрее, чем с использованием пробелов
      Аналогично предыдущему пункту.

    Напоследок, хочу раз напомнить, что приведённые мною советы и факты не абсолютны и значимость их применения зависит от конкретной ситуации. Необходимо помнить, что оптимизация скриптов лишь малая часть от всей процедуры оптимизации и зачастую возможно спокойно жить без вышеописанных советов.

    Для написания статьи частично пользовались материалы:
    40 советов по оптимизации вашего PHP-кода,
    Кропотливая оптимизация PHP-приложений,
    На пути к идеалу
    AdBlock has stolen the banner, but banners are not teeth — they will be back

    More
    Ads

    Comments 215

      +37
      Ох ща холивары-то начнутся.
      Использование сложных запросов к БД быстрее, чем использование нескольких простых
      Использование вычислений на стороне СУБД быстрее, чем вычисления на стороне PHP для данных хранящихся в БД.

      Бро, это совсем и совсем неправильно. Ресурсы PHP масштабируются линейно добавлением серверов. Написать же базу (подразумеваем SQL), которую можно легко масштабировать добавлением сервером очень и очень геморно. Мало какой хайлоад проект джойны использует — не то, чтобы сложные запросы.
      И это, добавь куда-нибудь в начало пунктики про использование оп-кешеров кода — APC, eAccelerator, XCache.
        +17
        Использование сложных запросов к БД быстрее, чем использование нескольких простых


        Тоже в глаза бросилось. Не согласен с автором.
          +28
          Да ну и вообще. За годы работы с PHP у меня сложилось мнение, что этот не тот язык, который надо оптимизировать. Ну это пустое занятие. Как правило, если появляются проблемы с сайтом, который, например, медленно работает, то это на 99 процентов не беда языка — это проблема архитектуры приложения и взаимодействия его компонентов.
          Ну если уж вы попали в тот 1 процент — просто добавьте еще серверов. Они нынче такие дешевые.
          Ну и, конечно же, не забываем Кнута:
          «Преждевременная оптимизация — это корень всех бед»
            +3
            Абсолютно согласен. Писать надо красиво, быстро — но без фанатизма. Ибо легче 100 руб за ресурсы доплатить, чем менять switch -и на if — ы.
              +2
              А потом еще дебажить все это ))
              0
              Полностью согласен. Проблемы часто именно в архитектуре, кривых запросах и, как раз, сложных запросах, которые порой приходится переписывать на несколько простых, чтобы увеличить скорость. А вот оптимизация на спичках типа писать $var. ' text' вместо "$var text" давно уже считается экономией на спичках. В том же стандарте кодирования Zend сказано что если в строке встречаются одинарные кавычки, тов место записи 'some \'text\' ...' надо писать «some 'text' ...» ибо важнее читаемость кода и его дегкостьв отладке, чем такие оптимизации. Это частный случай, конечно, но все уже уже устал читать про такие оптимизации
                0
                У меня сложилось мнение, что 99 процентов это г@внозпросы к БД. Так что надо в первую очередь оптимизировать именно эту составляющую… И это не всегда переход к сложным запросам. Иногда, разбиение таковых на более мелкие и последующая группировка/сортировка и т.д. их на PHP. Как на одной конференции сказал представитель Бегуна, — «ресурсы PHP гораздо дешевле, чем MySQL» (в частности). Так что первый шаг, это переход на LazyLoad, IdentytiMap, UnitOfWork…

                Ну а код должен быть понятным и читаемым ))
                Бывают, конечно, и алгоритмические ошибки. Но это касается любого языка, а не только PHP.
              +34
              экономия на спичках
                +2
                При чём часто надуманная. К примеру, sizeof() на массивах отрабатывает моментально. А is_null() является языковой конструкцией, а не функцией. При гонке за миллисекундами надо писать на C/C++ (хоть в standalone, хоть в виде модуля), а не заниматься микросекундной обфускацией.
                +7
                Мне кажется, у начинающих (для них же эта статья?) если что и тормозит, то это не PHP, а база.
                А оптимизацией php надо заниматься уже на масштабах Facebook.
                  0
                  Ну не скажите. Мы, например, выпускаем устройства с дохленьким arm-процессором, на котором кроме всего прочего крутится веб-админ на php. Приходится поневоле заниматься оптимизацией, чтобы странички по 30 секунд не генерились. :-)
                    –4
                    жесть. другие языки, более легкие по ресурсам, не пробовали — типа lua?
                      0
                      Я на caanoo (тоже arm) поделываю скриптики (графические с использованием SDL), и php обгоняет lua (в виде LOVE) очень и очень сильно. Графические функции (самые долгие) написаны на Си, и очень быстры. По факту, раз в 5-7 быстрее, чем lua.
                        0
                        причем тут C? что мешает на lua писать так же расширения?
                        вообще клево сравнили обработку графики и веб.
                  +3
                  К сожалению, интерпретатор PHP не может работать с ООП также быстро как с обычными функциями.

                  Понятное дело. Статья по «оптимизации», но надо добавить " скорости интерпретации и выполнения". Оптимизация разная бывает — может архитектурная, может лаконичности кода. И зачастую легче написать приложение, работающее в 2 раза медленнее чем эталон, но зато легко и быстро изменяемое. Если нужна скорость — ASM в помощь.

                    +1
                    Ну, может, если не ASM то «c» точно поможет.
                    +20
                    Я бы не сказал, что совет не использовать ООП — хороший :)
                      +6
                      Еще можно писать сразу машинный код — распределяя тем самым нагрузку между интерпретатором и программистом :-)
                        0
                        только между программисто и программистом, до сервера не дойдет. :)
                      +2
                      echo $var.«text» быстрее, чем echo "$var text"


                      Если нужно конкатенировать несколько переменных, то второй вариант как раз будет в плюсе по скорости, потому что у интерпретатора имеется возможность один раз выделить буфер под строку нужного размера, вместо выполнения цепочки пошаговых конкатенаций.

                      readfile быстрее, чем file_get_contents, file_get_contents быстрее, чем require, а require быстрее, чем include для вывода статического контента из отдельного файла


                      Жесть :)
                        +1
                        Много конкатенаций подряд на мой взгляд существенно снижает их читаемость. Иную строку пока разберешь — глаза поломаешь )
                        +25
                        О. Опять статья о том, что если утром встать с правой ноги, а не левой, то быстрее дойдёшь на работу.
                          +24
                          прочитав заголовок, сделал предположение что статья о скорости кавычек и echo. Открыл — таки да, о них :)
                            +3
                            «Так и вышло»
                              +23
                              'Так и вышло'
                                +17
                                ?>так и вышло <?php
                                  –5
                                  А вот за такое надо расстреливать без суда и следствия.
                                    +4
                                    Вы приверженец вывода статики через echo или использования отличных от php шаблонизаторов? Расстреливать по-моему надо за echo 'так и вышло'.
                                      –3
                                      Я приверженец монолитного кода и отделения логики от представления.
                                        +7
                                        А логику представления куда денете?
                                          0
                                          $logic->replaсe('{result}','Так и вышло');
                                            0
                                            Это не значит, что я поддерживаю данный DLE и UMI подход.
                                              +1
                                              Имеет право на жизнь, конечно, но мне кажется, что вынос статического текста из шаблона не есть хорошо. В шаблоне должны быть статические данные (разметка, «навигационные фразы» и т. п.) и логика представления (вывести столько строк таблицы, сколько в каком-то массиве), а «плейсхолдеры» заменяться на динамические из БД и файлов настроек, но ни в коем случае не на захардкоденные где-то в недрах приложения. Причина простая — такие данные должен быть способен изменить не программист, а или администратор сайта (динамические — через админку, бд или конфиги), или верстальщик (статические). Речь, конечно не идёт об, условно говоря, «коробочных» продуктах типа CMS, где настраиваться не программистом должно всё, но и там захардкоденные строки, имхо, исключены.
                              +8
                              include('абсолютный путь') быстрее, чем include('относительный путь')

                              Дааам-с… И это в не значительные оптимизации?

                              Уважаемый, хоть тут и ежу понятно что абсолютный путь быстрее, а так же зависит от нескольких факторов, но по поводу её незначительности вы промазали ядерной боеголовкой +- пара тысячь километров. Если у вас include_path содержит хотя бы 3-4 папки и эти папки записаны в абы каком порядке (а я видал include_path по 7-12 папок), то потерять можно порядка 30% производительности. А штука вот в чём, когда относительный путь ищется, идёт проверка через stat каждой директории по порядку, а есть ли там чёртов файл, который надо подключить. И как вы думаете, сколько таких вызовов на КАЖДЫЙ подключаемый скрипт образуется? Возмите любой фреймворк где используется более-менее приличное кол-во компонент и поиграйтесь. Будете удивлены.
                              Кривой include_path — одна из тех злостных вещей, которая бъёт в самый центр. На ряду с кривой базой. Подтверждено личным опытом, когда оптимизировал один из проектов. strace просто с ума сходил от кол-ва stat вызовов, а системные вызовы как мы знаем очень дорогие. Оптимизация include-path + правильная расстановка относительных путей уже сильно спасает.
                              Так что я бы убрал из безполезных.
                                +2
                                Когда начинается такая оптимизация на спичках — надо искать узкие места не кода, а алгоритма. Не поверю что алгоритм оптимизирован на все 100%! По поводу БД: 1-ая таблица — 5 млн. записей, 2-ая таблица — 8 млн. записей. Из первой возвращается 20 записей, из второй — ~60-80. На запрос по первичным ключам тратится около 0,0005 сек. На запрос с джойном — 1,5 секунд.
                                Товарищ — не думаю что цикл на 80 итераций займёт 1,5 секунд времени! Данный факт исследован, профилирован и вылизан до мелочей у нас на проекте.
                                  +1
                                  Что-то долго у вас запрос с джоином выполняется.
                                • UFO just landed and posted this here
                                    +5
                                    хаброрерайтеры настолько суровы, что указывают ссылки на исходный контент
                                      +3
                                      "$row['id'] быстрее, чем $row[id]"

                                      Тут надо указать, что второй способ вообще не рекомендуется применять, потому как у вас теоретически может быть задана константа с таким именем. Если в массиве ключи строковые, то их и записывать надо в виде строк.
                                        +14
                                        Это вредные советы?
                                          +1
                                          А еще, замените все 'случаи' на 'случае', глаз режет. Аж 6 раз.
                                            0
                                            >preg _replace быстрее, чем ereg_replace, str_replace быстрее, чем preg_replace, но strtr быстрее, чем str_replace

                                            Решил потестить насколько preg vs ereg в числах.
                                            Получилось следующее (проводилось 100к иттераций в цикле).
                                            Искалась строка в 3 статичных символа.

                                            К примеру, большая строка (18200 байт), искаемого в ней нет:
                                            preg 4.599s
                                            ereg 6.959s

                                            Такая же большая строка, искаемое есть в начале строки:
                                            preg 0m5.045s
                                            ereg 2m22.052s — тут конечнослив по полной.

                                            Такая же большая строка, искаемое есть в конце строки:
                                            preg 0m6.612s
                                            ereg 3m10.676s — снова слив, вполне ожидаемый.

                                            Урезаем строку до 64 байт. Искомое отсутствует:
                                            preg 0m0.113s — 0m0.121s
                                            ereg 0m0.123s — 0m0.123s

                                            Видим не такой уж большой разрыв.

                                            Снова строка 64 байт. Искомое присутствет в начале строки:
                                            preg 0m0.131s — 0m0.140s
                                            ereg 0m0.179s — 0m0.183s

                                            Снова строка 64 байт. Искомое присутствет в конце строки:
                                            preg 0m0.203s — 0m0.218s
                                            ereg 0m0.494s — 0m0.503s

                                            Регексп с патерном в 11 символов (в центре) по строке в 64 символа
                                            preg 0m0.143s — 0m0.146s
                                            ereg 0m0.647s — 0m0.664s
                                              +5
                                              ereg вообще deprecated в 5.3
                                                0
                                                у меня сервера билдились во времена 5.2.х, обновлять debian old stable занятие не для продакшена, ога.
                                              +4
                                              >echo $var."text" быстрее, чем echo "$var text"

                                              Одинаково. А то и медленнее. Быстрее будет
                                              echo $var.'text'

                                                +5
                                                Ещё быстрее echo $var,'text'
                                                А ещё быстрее echo $var ?>text<?php
                                                  0
                                                  shitcode detected… :)
                                                  Вот благодаря таким советам потом и появляются матюки…
                                                  Такой код поддерживать — это чистый вынос мозга.
                                                    +5
                                                    Во-первых я не говорил, что этот код лучше. Он быстрее, согласны?
                                                    Во-вторых такой код вполне приемлем в шаблоне. И он очень красиво смотрится.
                                                    <?php if($f->type == 'visible'): ?>
                                                    <tr>
                                                      <td class="label"><?php echo $f->label; ?>:</td>
                                                      <td><?php echo $f->element; ?></td>
                                                    </tr>
                                                    <?php elseif($f->type == 'hidden'): ?>
                                                    <tr style="display: none;">
                                                      <td colspan="2"><?php echo $f->element; ?></td>
                                                    </tr>
                                                    <?php endif; ?>
                                                      –9
                                                      честно говоря, за такую мешанину кода и оформления я бы расстреливал на месте
                                                        –7
                                                        Во-во, php вообще должен генерировать только xml, нечего всем этим td, tr делать в .php-файле.
                                                          +5
                                                          Это кусок нормальной вьюхи. То есть полноценный шаблон.
                                                          Который не вгоняет в ступор верстальщика, который что-то стоит.

                                                          Мешанина html и php выглядит далеко не так.
                                                            –1
                                                            В ступор может и не вгоняет — но к чему верстальщику php-логика с лишними для него тегами в шаблоне? Визуальный мусор, который можно править только в текстовом редакторе. А часто приходится гнать наблоны из готовой верстки чуть ли не прямо из DW. В идеале он должен выдать чистый html с названиями переменных на нужных местах. Не касаясь холиваров по поводу шаблонизаторов — с точки зрения верстальщика такой удобный способ был реализован в пресловутом и далеко не идеальном vBulletin (особенно в старых версиях до 3.x)
                                                              0
                                                              В шаблонах не должно быть бизнес-логики. С этим я разумеется согласен.

                                                              Далее.

                                                              Все шаблонизаторы, это забавная идея: а давайте мы предположим, что верстальщик дебил и сделаем недоязык для его недомозга. Этого ему хватит в 96% случаев.

                                                              Я был сторонником этой идеи. К счастью это в очень далёком прошлом.

                                                              Если вы в шаблонах хотите ограничиться только переменными, то файлов шаблонов будет ну очень много в более менее серьезных вещах.
                                                                0
                                                                Их количество это наверное единственный минус такого подхода.
                                                                  0
                                                                  Вот если все такие умные, то почему среди лучших free CMS, по различным версиям, являются такие костыли, как Joomla, Wordpress или Drupal?

                                                                  Про платные я вообще молчу. Одному Ктулху известно, что кроется в их загварженом коде.

                                                                  Так где же она тогда, эта идеальная CMS?

                                                                  К слову, все вышеперечисленные free используют нативный шаблонизатор. Однако ползать, как беременным тараканам, этим CMS ничто не мешает.
                                                            +4
                                                            без шортегов не кошеро
                                                              –1
                                                              Лично я от такого кода ушел давным-давно, когда понял, что стоимость установки второго-третьего-четвертого сервера, чем городить такие вот заглушки в HTML-е… мне намного больше нравится вот такой код:
                                                              1 файл somefile.php:
                                                              <

                                                              $this->smarty->assign(«somedata», $f->data);

                                                              ?>
                                                              2 файл somefile.tpl:
                                                              {-- if $item.type eq 'visible' --}

                                                              {-- $item.label --}
                                                              {-- $item.element --}

                                                              {-- elseif $item.type eq 'hidden' --}

                                                              {-- $item.element --}

                                                              {-- /if --}

                                                              Хотя если быть точным, то подобный кусок кода примера — вообще является полным гавном… так как в такой структуре данных явно есть какая-то ошибка.
                                                                0
                                                                парсер лох… вырезал нафик все теги, блин… (

                                                                {-- if $item.type eq 'visible' --}
                                                                <tr>
                                                                <td class=«label»>{-- $item.label --}</td>
                                                                <td>{-- $item.element --}</td>
                                                                </tr>
                                                                {-- elseif $item.type eq 'hidden' --}
                                                                <tr style=«display: none;»>
                                                                <td colspan=«2»>{-- $item.element --}</td>
                                                                </tr>
                                                                {-- /if --}
                                                                  +1
                                                                  К давнему аргументу холивара «пхп вс смарти» о том, что 96% (да-да, я измерял :) ) кода смарти «транслируется» в код пхп через find&replace возвращаться не буду :) Но вот в примере кода ничего предосудительного не вижу. Не поделитесь, что вы увидели?
                                                                    –1
                                                                    Чтобы не переводить в тему холивара. Такого плана код применим в одном случае: на продакшне, с уже готовым дизайном и версткой, которому не требуются изменения, обкатанный на все 100% и приносящий достаточный доход. Если же у Вас проект в разработке, у которого не сильно большая нагрузка, идет добавление кучи функционала, части сайта могут меняться часто, и причем не только в HTML, но и при смене внутренней логики. Только представьте себе что будет, если потребуется изменить таблицу на див-блоки, а еще веселее если переименуется класс $f в нормальное и понятное для человека имя типа $users_list_data. Кстати имена переменных это совсем отдельный вопрос. Говорить о комментировании подобного кода это вообще полная прострация.
                                                                    Извините, за сумбурность, несколько спешу, так как киндер которому 1 месяц очень сильно отвлекает от Хабра… ))
                                                        +1
                                                        Вставлю и я своих пять копеек. Например если вы заранее знаете дату, то не стоит писать NOW() в запросе, можно вычислить время на стороне php и сразу подставить в запрос. То же самое в случае field1 -2 > 0, можно просто написать field1 > 2. Примеры синетические, но я думаю мысль в общем понятна.
                                                          0
                                                          Причина — MySQL (про другие сервера не знаю) не будет кэшировать результаты запроса с NOW(), а с чем-то вроде '2011-01-26 10:45:17' закэширует — если кэширование не используется, то и выигрыша не будет (вероятно). Плюс нужно быть осторожным с полями, автоматически изменяемыми при добавлении/изменение записи (типа created_at, updated_at) — время на аппсервере и сервере БД может различаться, пускай на миллисекунды, но нужные строки могут в результат не попасть (или попасть не нужные)

                                                          Для проектов где важна синхронизация всех клиентов (типа MMOG), лучше использовать во всех запросах $_SERVER['REQUEST_TIME'] не сколько с целью оптимизации (кэширование всё равно работать не будет, если в запрос включен id клиента и запросы реже раза в секунду) сколько с целью точной синхронизации.
                                                            0
                                                            Кэширование — это только один аспект NOW(), это влияет за собой репликацию как минимум. Что касается системных часов, то я всегда считал что они должны синхронизироваться с эталоном (будет эталоном общедоступный сервер времени или локально поднятый, здесь уже не так важно).
                                                            P.S. Я редко сталкивался с проектами, в которых рассинхронизация времени на милисекунды была бы критична.
                                                              0
                                                              Несколько миллисекунд рассинхронизации все равно могут быть, а такая рассинхронизация может выливаться в секундную, для проектов, основанных на очереди событий и серверных «тиках» это может оказаться критичным или вызывать трудно повторяемые баги.
                                                          +1
                                                          Старайтесь не использовать require_once или include_once неоднократно по отношению к одному и тому же файлу. Иначе Вы элементарно теряете время на повторное считывание файла.

                                                          Возможно автор имел ввиду require или include? Потому как при использовании require_once интерпретатор проверяет, был ли подключен указанный файл ранее или нет, и если да повторного подключения не будет.
                                                            0
                                                            Автор имел в виду, что ***_once как раз и делает эту лишнюю проверку.
                                                              0
                                                              Он уже исправил, до этого было написано, что если использовать *_once файл будет загружен снова.
                                                            +16
                                                            * Постоянно профилируйте свой код на сервере (xdebug) и на клиенте (firebug), что бы выявить узкие места кода

                                                            и так, на production, отжирая 50% проца, висел xdebug…

                                                            * «Критически тяжёлые» функции желательно реализовать на стороннем языка программирования в виде расширения PHP

                                                            ага. а как часто это будет отваливаться — никто не учитывает?

                                                            * Различие повремени на клиенте может составлять около 1 секунды, поэтому имеет смысл четкое разделение статики и генерируемых средствами PHP страниц.

                                                            это как? или у нас PHP на клиентской стороне обрабатывается?

                                                            * Старайтесь не использовать require_once или include_once неоднократно по отношению к одному и тому же файлу Иначе Вы элементарно теряете время на повторное считывание файла.

                                                            буга. бугага. бугагагагага. на то они и once, чтобы повторно не считывать. или вы еще на 4.2 где этот баг был?

                                                            * Желательно использовать проверку отправляемых данных на клиенте Это вызвано тем, что при проверке данных на стороне клиента, резко снижается количество запросов с неверными данными. Системы проверки данных на клиенте строятся в основном с использованием JS и жестких элементов формы (select).

                                                            ей. инетбанк такой напишите пожалуйста, я схожу его поломаю

                                                            * Желательно большие конструкций DOM для массивов данных строить на клиентеЭто очень эффективный метод оптимизации при работе с отображением большого объёма данных. Суть его сводится к следующему: на сервере подготавливается массив данных и передаётся клиенту, а построение конструкций DOM предоставляется JS функциям. В результате нагрузка частично перераспределяется с сервера на клиент.

                                                            это в gwt справедливою в PHP — нет.

                                                            * Используйте постоянное соединение с БД при малом количестве одновременно активных клиентов

                                                            первый небредовый совет )

                                                            * Например можно использовать следующий простой подход: получаем данные выборки из БД и сохраняем их как сериализованный массив в файл

                                                            так вот откуда растут монстры с миллионами (я видел) файлов кеша :)
                                                            и потом спрашивают — а что все тормозит.
                                                            запомните — никакие нахрен файлы не смогут управлять кешем так как тот же memcached.

                                                            * Работа без объектов (без ООП) быстрее, чем работа с использованием объектов, примерно, в три раза

                                                            ассемблер в студию

                                                            * По времени считывания пустого файла колебания от 0.001 для readfile до 0.002 для include.

                                                            это на калькуляторе или первом пентиуме?
                                                            у меня на сервере около 0.00013 для 1000 чтений.

                                                            * $row['id'] быстрее, чем $row[id]

                                                            это вообще ошибка в коде, доррогой мой. второй случай — исключение и приведение неизвестной константы к строке

                                                            Товагищи! У нас таки-завелся либо очень олскульный, либо просто говнокодер, который в века баз на миллионы строк, невроткубических можностей амазона оптимизирует PHP в стиле 4.2 кода бородатого 2000 года. Это ужасно и печально.

                                                            А вообще — десткая статья. Если надо выбирать между опддерживаемостью и оптимальностью — надо выбирать поддерживаемость, уж поверьте мне.
                                                              +2
                                                              >и так, на production, отжирая 50% проца, висел xdebug…
                                                              Ну как бы подразумевается, что речь идет о dev (на худой конец staging) окружении.

                                                              >ага. а как часто это будет отваливаться — никто не учитывает?
                                                              Кривизна рук в общем не учитывается, да.

                                                              >это как? или у нас PHP на клиентской стороне обрабатывается?
                                                              Отдаем статику ngnix, динамику — апачем+PHP. ЧЯДНТ?

                                                              >ей. инетбанк такой напишите пожалуйста, я схожу его поломаю
                                                              Согласен, тут автор пишет о том чего не знает (не понимает).

                                                              >это в gwt справедливою в PHP — нет.
                                                              От сервера получаем массив вида row=>[cell1, cell2, cell3]… и строим таблицу JS'ом. Что не так?



                                                              Далее согласен. Экономия на спичках возведенная в фетиш порождает чудовищ.
                                                                +1
                                                                >>>От сервера получаем массив вида row=>[cell1, cell2, cell3]… и строим таблицу JS'ом. Что не так?

                                                                Можно и так. Но, если не юзать, gwt, extjs, yui...., то легче вернуть хтмл, который тихо-мирно описан в шаблонах.
                                                                Да и дизайнеру легче.
                                                                  0
                                                                  а люди с айпадами у которых jquery mobile подлагивает?

                                                                  и, кстати, фф тоже любит на client-side js тормознить. а уж все блокировщики подозрительных скриптов…
                                                                  +1
                                                                  >>ей. инетбанк такой напишите пожалуйста, я схожу его поломаю
                                                                  >Согласен, тут автор пишет о том чего не знает (не понимает).

                                                                  Насколько я понимаю, никто не предлагает отменять серверную проверку.
                                                                  Клиентская проверка должна отсекать ошибки в синтаксисе, либо заполненности обязательных полей. Таким образом кол-во запросов на сервер снизится.
                                                                  +4
                                                                  " Желательно использовать проверку отправляемых данных на клиенте Это вызвано тем, что при проверке данных на стороне клиента, резко снижается количество запросов с неверными данными. Системы проверки данных на клиенте строятся в основном с использованием JS и жестких элементов формы (select)."

                                                                  Здесь, скорее всего, имеется ввиду, что следует сделать первичную проверку данных на стороне клиента, что бы не делать лишних запросов на сервер.
                                                                  При этом валидацию данных на сервере никто не отменяет. Вот. )
                                                                  0
                                                                  require быстрее, чем include для интерпретируемых файлов
                                                                  Замечание: при ветвлении алгоритма, когда есть возможность не использовать интерпретируемый файл, надо использовать include, т.к. require подключает файл всегда.
                                                                  ага, в php4
                                                                    +1
                                                                    >Использование «отработавших» переменных быстрее, чем объявление новых
                                                                    >Или перефразирую иначе – Не создавайте лишних переменных.

                                                                    Фаулер в своём «Рефакторинге» считает ровно наоборот: одна переменная — одно назначение, в идеале одно присваивание
                                                                      0
                                                                      Рефакторинг — это не оптимизация, а улучшение поддерживаемости и читабельности.
                                                                        +2
                                                                        То, что описано в статье — это не оптимизация, а фигня полнейшая.
                                                                          0
                                                                          Оптимизация — по-моему, это, например, Substitute Algorithm у того же Фаулера.

                                                                          Использование же «отработавших» переменных — это идиотизм, а не оптимизация (не в обиду будет сказано) :) Нужно не экономить на спичках, а решать реальные проблемы производительности с профайлером наголо — есть ведь замечательные инструменты вроде webgrind.

                                                                          И оптимизировать отрефакторенный код не в пример легче и проще, чем код, который необдуманно следует всем вышеприведенным советам.

                                                                          В общем, «предварительная оптимизация — корень всего зла» © :)
                                                                            0
                                                                            Рефакторинг — это оптимизация поддерживаемости и читабельности. Вообще хотел сказать, что если одна часть советов не улучшает поддерживаемости и читабельности при хоть каком-то выигрыше, то другая их сильно ухудшает. Если автор писал для новичков, до я бы на его месте эти части отделил бы друг от друга или иным способом пометил «безболезненные» и «болезненные» оптимизации
                                                                          –3
                                                                          Статья для общего развития.
                                                                          • UFO just landed and posted this here
                                                                            0
                                                                            >preg _replace быстрее, чем ereg_replace, str_replace быстрее, чем preg_replace, но strtr быстрее, чем str_replace
                                                                            Разница во времени зависит от объёма данных и может достигать нескольких тысячных секунд.
                                                                            Функции работы со строками быстрее, чем регулярные выражения
                                                                            Это правило является следствием предыдущего.

                                                                            А мы случайно причину со следствием не путаем?
                                                                              0
                                                                              Друзья, а кто-нибудь может внятно объяснить, почему "$row['id'] быстрее, чем $row[id]", да ещё и аж в 7 раз?
                                                                              Заранее спасибо!
                                                                                +1
                                                                                Во втором случае интерпретатор сначала ищет константу с именем id, не находит (если повезло :) ), создаёт её, инициализирует строкой 'id', разыменовывает и только после этого подставляет полученную строку. Попутно выдает предупреждение, вообще конструкция $row[id] считается грубой ошибкой
                                                                                  0
                                                                                  Спасибо! Теперь в голове сложилась картинка.

                                                                                  а использование «текст $row[id] текст» — тоже плохо?
                                                                                    0
                                                                                    Плохо, очень плохо. Даже для читабельности кода.
                                                                                    Да и кавычки двойные тут на 0.000000001 секунды замедлят сразу же скрипт :)
                                                                                      0
                                                                                      выходит

                                                                                      echo «текст ». $row['id']. " текст"

                                                                                      лучше чем

                                                                                      echo «текст $row[id] текст»

                                                                                      так?
                                                                                        –1
                                                                                        нет. «text $var text» быстрее чем «text ».$var." text". Конкатенация работает медленнее, чем поиск переменных внутри строки.

                                                                                        P.S. А «текст $row[id] текст» разве работает? Наверное все-таки «текст {$row['id']} текст», не?
                                                                                          0
                                                                                          «текст $row[id] текст» — точно работает. часто пользовался, потому и интересуюсь.
                                                                                          «текст {$row['id']} текст» — про такое не знал :\
                                                                                            0
                                                                                            Не поверю. что Вы «Часто» пользовались первым, если не знаете про второе «текст {переменная} текст»!
                                                                                              0
                                                                                              Глупость Вы какую-то ляпнули, причём на уровне детского сада.
                                                                                              Я Вам доказывать ничего и не собираюсь в общем-то…
                                                                                              0
                                                                                              это для сложных массивов. типа echo " ${array['a']['b']} "
                                                                                              +2
                                                                                              P.S. А «текст $row[id] текст» разве работает? Наверное все-таки «текст {$row['id']} текст», не?

                                                                                              Работает и совершенно корректная конструкция.
                                                                                                0
                                                                                                Если прдварительно определить константу id и в row будет такой ключ ;)
                                                                                                  –1
                                                                                                  Нет, даже без определения константы.
                                                                                                    0
                                                                                                    Проверьте:
                                                                                                    <?php
                                                                                                    
                                                                                                    ini_set('display_errors', 'on');
                                                                                                    error_reporting(E_ALL);
                                                                                                    
                                                                                                    $a = array('id' => 7);
                                                                                                    
                                                                                                    echo $a[id];
                                                                                                    
                                                                                                    
                                                                                                      0
                                                                                                      Естественно будет ошибка.
                                                                                                    +2
                                                                                                    Более того, даже с определённой константой оно будет использовать только строковое значение:
                                                                                                    shock@shock:~$ php -r 'error_reporting(E_ALL | E_STRICT | E_NOTICE);
                                                                                                    > $array = array("id" => 15, "test" => 20);
                                                                                                    > define("id", "test");
                                                                                                    > echo "$array[id] \n";'
                                                                                                    15 
                                                                                                    
                                                                                                  0
                                                                                                  наоборот. конкатенация быстрее. почитайте те же symfony coding standarts.

                                                                                                  и да, «текст $row[id] текст» работает.
                                                                                                  +1
                                                                                                  echo «текст ». $row['id']. " текст"

                                                                                                  лучше чем

                                                                                                  echo «текст $row[id] текст»

                                                                                                  Нет. В большинстве случаев переменные прям строке намного лучше, чем конкатенация через точку.
                                                                                                    +1
                                                                                                    а еще лучше помогать интерпретатору выделяя переменные фигурными скобками:
                                                                                                    echo "текст {$row['id']} текст";
                                                                                                      0
                                                                                                      echo "текст {$row['id']} текст";
                                                                                                      // vs
                                                                                                      echo "текст $row[id] текст";
                                                                                                      

                                                                                                      ;)
                                                                                                        0
                                                                                                        Только что проверил, разницы вообще нет.

                                                                                                        <?
                                                                                                          $row = array('id' => 1297);
                                                                                                          $results = array();
                                                                                                          $tests = 1000000;
                                                                                                        
                                                                                                          $start = microtime(true);
                                                                                                        
                                                                                                          for($i = $tests; $i-- > 0;)
                                                                                                            echo $row['id'] , ' title';
                                                                                                          $results[] = (- $start + ($start = microtime(true)));
                                                                                                        
                                                                                                          for($i = $tests; $i-- > 0;)
                                                                                                            echo $row['id'] . ' title';
                                                                                                          $results[] = (- $start + ($start = microtime(true)));
                                                                                                        
                                                                                                          for($i = $tests; $i-- > 0;)
                                                                                                            echo "$row[id] title";
                                                                                                          $results[] = (- $start + ($start = microtime(true)));
                                                                                                        
                                                                                                          for($i = $tests; $i-- > 0;)
                                                                                                            echo "{$row['id']} title";
                                                                                                          $results[] = (- $start + ($start = microtime(true)));
                                                                                                        
                                                                                                          var_dump($results);
                                                                                                        ?>


                                                                                                        На Core i5-750 и PHP 5.3.3, результаты одинаковы: ~0.8с для миллиона(!) выводов, причем это не чистое время, т.к. есть оверхед из-за фора.
                                                                                                          0
                                                                                                          Конечно нету =) Разница только визуальная
                                                                                                            +1
                                                                                                            Вариант со скобочками предпочтительнее, т.к. он лучше читается и он надежнее, можно не думать правильно ли интерпретатор распарсит переменную в строке.
                                                                                                              0
                                                                                                              Вариант со скобочками читается хуже, особенно в нормальном редакторе с подсветкой, но на счёт последнего — согласен, да
                                                                                                                0
                                                                                                                Наверно первое — это дело привычки, мне со скобочками читабельнее, пользуюсь PHPStorm'ом :)
                                                                                                                  0
                                                                                                                  я — Нетбинсом =)
                                                                                                            0
                                                                                                            А откуда ж браться разнице? Парсер, он же не дурак. Он один раз всё парсит, а потом просто выполняет :)
                                                                                                            А с точки зрения выполнения конструкции почти одинаковые.
                                                                                                              0
                                                                                                              Почему-то мне кажется, что $row[id] должна выдавать варниг в любом контексте (если все ошибки включены)
                                                                                                                0
                                                                                                                shock@shock:~$ php -r 'error_reporting(E_ALL | E_STRICT | E_NOTICE);
                                                                                                                $array = array("id" => 15);
                                                                                                                echo "$array[id]\n";'
                                                                                                                15
                                                                                                                shock@shock:~$ php -v
                                                                                                                PHP 5.3.1-0.dotdeb.1
                                                                                                                
                                                                                                                  0
                                                                                                                  Спасибо, интересно, не знал :) Но пользоваться, пожалуй, не буду

                                                                                                                  На дотдебе, кстати, 5.3.5 уже давненько (относительно) лежит, или есть причины 5.3.1 использовать?
                                                                                                                    0
                                                                                                                    Я просто сейчас на компе, который давно не апгрейдил. Даже ось старая стоит. Всё хочу поставить другой дистр, но никак не найду времени.
                                                                                                                    Вывод — причин нету.
                                                                                                                      0
                                                                                                                      Пожалуйста. Кстати, почитать можно тут: php.net/manual/en/language.types.array.php
                                                                                                                      Начиная со слов «More examples to demonstrate this behaviour: „
                                                                                                                        0
                                                                                                                        Видимо когда-то хватило слов «This is wrong» :)
                                                                                                            0
                                                                                                            это понятно. но настолько ли отсутствие конкатенации лучше, что компенсирует в 7 раз большую «медленность» конструкции $row[id] по сравнению с $row['id']?
                                                                                                              +1
                                                                                                              В кавычках это правило не работает, поиска по константам не осуществляется
                                                                                                                0
                                                                                                                Именно это я и хотел прояснить.
                                                                                                                Спасибо огромное! :)
                                                                                                  +8
                                                                                                  Ужас.
                                                                                                  Тупые советы, значительно ухудшающие код (используйте одни и те же переменные, не используйте ООП, не вызывайте функции), основанные на догадках (1/2 вызывает деление? Не верю что интерпретатор PHP настолько туп), действующие далеко не всегда (ajax значительно быстрее? Под большой нагрузкой, вовсе не факт, что 10 маленьких запросов отработают быстрее, чем один большой), экономящие аж тысячные/милионные доли секунды.
                                                                                                  При том что грамотные индексы, кэширование, акселераторы, правильные алгоритмы дадут прирост производительности выше на несколько порядков.
                                                                                                    –1
                                                                                                    именно так. на быдлокоде часто такие же быдлячные запросы к бд. хотя сам пхп код может работать предельно быстро (ну то есть тупой линейный код с небольшим количеством функций)
                                                                                                    0
                                                                                                    Как говорил то ли Фаулер, то ли Бек: «Окончательный ответ может дать только профайлер». Это раз.
                                                                                                    Ну и во-вторых, на продакшне можно ставить xhprof, хотя бы на одном из серверов, если на то есть необходимость.
                                                                                                    Но, как показывает опыт, узкое место всегда одно и то же: база данных,
                                                                                                      +4
                                                                                                      Местами такой бред:

                                                                                                      sizeOf быстрее, чем count

                                                                                                      ru.php.net/manual/en/function.sizeof.php
                                                                                                        +1
                                                                                                        0.5 быстрее, чем 1/2 Причина в том, что во втором случае выполняется операция деления.
                                                                                                        Кэп? Конечно во втором случае делится, а в первом константа.
                                                                                                        Теперь без шуток. 200/2 быстрее чем 200 * 0.5 ибо в первом случае выполняется целочисленное деление, а во втором случае умножение в FPU вот 1.5/2 будет медленнее в 2 раза чем 1.5*0.5 тест когда-то проводился на Intel Pentium IV Так что тут нельзя однозначно заявлять.
                                                                                                          +2
                                                                                                          ob_start(); echo 'a'; echo 'b'; ob_end_flush(); быстрее, чем $return='a'; $return.='b'; echo $return;

                                                                                                          смеетесь? то есть установить глобальный перехват вывода PHP БЫСТРЕЕ, чем напечатать переменную?!
                                                                                                            0
                                                                                                            echo $var."text" быстрее, чем echo "$var text"

                                                                                                            Скажите мне, а где тут разница?
                                                                                                            PHP все равно зайдет в двойные кавычки для поиска переменной.
                                                                                                            Правильней будет так:
                                                                                                            echo $var . 'text' быстрее, чем echo "$var text"
                                                                                                              0
                                                                                                              ога. только еще быстрее на медленнее поменять, так как с точностью все наоборот (конкатенация медленнее поиска в строке)
                                                                                                                0
                                                                                                                Если внутри двойных кавычек нет переменных, то они сравниваются по скорости с одинарными (разница оооочень мизерная).
                                                                                                              • UFO just landed and posted this here
                                                                                                                  +1
                                                                                                                  Ужас какой то. Особенно про «Использование сложных запросов к БД быстрее».
                                                                                                                    0
                                                                                                                    Ага. Вот есть в проекте у нас такие запросы, по 10 джоинов, в таблицах чуть ли не по миллиону записей. Запрос аж 6 секунда выполняется иногда ) И вот попробуй докажи, всё пытаются какие-то неведомые индексы к таблицам добавить )))
                                                                                                                      +1
                                                                                                                      У нас в проекте несколько таблиц милионников размерами от сотен до гигабайт, запросы больше 0.2с редкость, да и те в моменты пиковой нагрузки. Индексы решают, главное правильно ими пользоваться, только расстановки индексов не всегда достаточно, частенько надо немного поправить сам запрос, а иногда и переписать.
                                                                                                                      0
                                                                                                                      да тут к половине советов надо приписывать «в некоторых случаях ...»
                                                                                                                      –1
                                                                                                                      сломал глаза, смотря на это:

                                                                                                                        +5
                                                                                                                        плюсующих статью больше чем минусующих. мда, хабр уже не торт.
                                                                                                                        вот повисит такое на главной, детишки поначитаются, и на полном серьёзе будут делать «профессиональные вставки» и пр.
                                                                                                                          +1
                                                                                                                          Да ладно вам, есть и хорошая сторона — после этого мы станем ценнее как специалисты ;)
                                                                                                                            0
                                                                                                                            Не МЫ, а ОНИ. МЫ о таких штуках задумываемся много позже, когда все оптимизации а верхнем уровне абстракции сделаны (такого не будет никогда)!
                                                                                                                          +3
                                                                                                                          «Инкремент инициализированной переменой i=0; ++i; быстрее, чем не инициализированной ++i»

                                                                                                                          Начинать работать с не инициализированными переменными нельзя, или у вас поощряются нотисы?

                                                                                                                          Да и вообще, 80% советов можно смело переносить в пункт «Бесполезная оптимизация».

                                                                                                                          Если же у вас проект, в котором нагрузки такие, что не хватает скорости самого php, то думаю что нужно менять язык, а не применять эти советы.
                                                                                                                          • UFO just landed and posted this here
                                                                                                                              +6
                                                                                                                              В этом году еще не было.
                                                                                                                                0
                                                                                                                                «Использование сложных запросов к БД быстрее, чем использование нескольких простых»
                                                                                                                                Очень спорный момент, не стоит перекладывать нагрузку на сервер БД, когда база начнет задыхаться её будет сложнее масштабировать.
                                                                                                                                  +1
                                                                                                                                  > Получение данных из файла быстрее, чем из БД
                                                                                                                                  Есть много случаев когда обращение к БД быстрее:
                                                                                                                                  — запрос попал в кеш, выборка делается из ОЗУ, что априори на порядки быстрее чем чтение из файла.
                                                                                                                                  — запрос в таблицу типа MEMORY, тут собственно опять нету обращения к диску, поэтому как и в предыдущем вариант на порядки быстрее.
                                                                                                                                  — запрос «в индекс» будет быстрее в большинстве случаях, ибо индекс обычно «висит» в памяти, что в очередной раз быстрее на порядки чем обращение к диску
                                                                                                                                  — …
                                                                                                                                  Подобных оптимизаций со стороны БД достаточно много, чтобы все тут перечислять, стоит ли овчинка выделки?

                                                                                                                                  > Если данные выборки из БД редко меняются и к этим данным обращается множество пользователей, то имеет смысл сохранить данные выборки в файл
                                                                                                                                  И тут не согласен:
                                                                                                                                  — если данные редко меняются и часто читаются — БД сама всё закеширует (для несложных запросов естественно)
                                                                                                                                  — если данные и редко читаются, и редко меняются, то стоит лих их вообще куда-то кешировать?
                                                                                                                                  — если запрос сложный и часто испольщуется, то:
                                                                                                                                  1) можно кешировать данные в PHP, например с помощью APC или memcached
                                                                                                                                  2) закешировать в таблицу типа MEMORY. Например, для материализованных вьюх.

                                                                                                                                  Работа без объектов (без ООП) быстрее, чем работа с использованием объектов, примерно, в три раза
                                                                                                                                  вы разрабатываете PHP4? В PHP 5.3 разница не такая существенная, а вот проект поддерживать несоизмеримо проще.

                                                                                                                                  Инкремент инициализированной переменой i=0; ++i; быстрее, чем не инициализированной ++i
                                                                                                                                  Это не должно быть оптимизацией, т. к. переменные надо инициализировать всегда.

                                                                                                                                  Использование «отработавших» переменных быстрее, чем объявление новых
                                                                                                                                  Попробуйте отладить код состоящий из переменных $a, $b, $i, $tmp, $temp,… Данное утверждение верно только в том случае, когда новое значение будет такого же типа как старое ;-)
                                                                                                                                    +1
                                                                                                                                    Если уж так, то где про хранение «NULL» в базе?
                                                                                                                                      0
                                                                                                                                      Когда-то столкнулся с вариантом, что:

                                                                                                                                      $array['a'] = 1;
                                                                                                                                      $array['b'] = 1;
                                                                                                                                      $array['c'] = 1;

                                                                                                                                      И потом if (isset($array['a'])) {} На порядок быстрее, чем создание массива $array = array('a', 'b', 'c'); и последующий поиск переменной в нем.
                                                                                                                                        0
                                                                                                                                        искали чем?
                                                                                                                                          0
                                                                                                                                          in_array
                                                                                                                                          array_search
                                                                                                                                            0
                                                                                                                                            странно, вообще насколько мне известно, пхп хранит такие хэши в виде двух массивов — массив ключей и массив значений. то есть разницы быть не должно никакой — и в том, и в другом случае пхп сканирует массив, совершенно одинаковым способом.
                                                                                                                                              0
                                                                                                                                              www.google.com.ua/search?hl=ru&q=in_array+slow&aq=f&aqi=&aql=&oq=

                                                                                                                                              В целом — можете проверить за пару минут — сгенерируйте два массива по 1000 элементов и потом пройдитесь по нему с таймером. Разница между isset и in_array будет очень ощутимая.
                                                                                                                                        +7
                                                                                                                                        Почти весь выигрыш от оптимизация PHP-кода сожрется 4-5 запросами (даже оптимизированными) к БД.

                                                                                                                                        И вообще, советы детсадовские. Например, про инкремент несуществующей переменной. Я даже не знаю, кому бы это пришло в голову :-)
                                                                                                                                        • UFO just landed and posted this here
                                                                                                                                            0
                                                                                                                                            на большом количестве запросов в секунду (к бд конечно же) — пконнект выгоднее, ибо tcp коннект (а ведь там происходит много всего включая аутентификацию) может быть медленнее, чем простой запрос и быстрый ответ. попробуйте простые «прекомпиленные» запросы через mysqli (ну или Perl DBD) использовать — на большых rps особенно заметно
                                                                                                                                            • UFO just landed and posted this here
                                                                                                                                                0
                                                                                                                                                Вот почему у меня они не глючат то?
                                                                                                                                                Никакой винды, БД уже лет 10 как на отдельных серверах, так что речи о unix sockets вообще не идет.
                                                                                                                                                В принципе я говорил не совсем о high load в истинном понимании. Просто сталкивался с задачей по быстрому впихиванию в бд простых и мелких данных, генерящихся «на лету» типа логов. Выигрыш от использования «пконнекта» был заметен, а использование mysqli->prepare, bind_param, execute добавило еще скорости вставки в разы.

                                                                                                                                                P.S. пойду сделаю тестик :-)
                                                                                                                                                  0
                                                                                                                                                  потестил
                                                                                                                                                  на ненагруженном тест стенде pconnect выигрывает на 100к INSERT'ах в среднем 0.8-1.1 секунды относительно connect.
                                                                                                                                                  Использование mysqli->prepare, bind_param, execute (в цикле только execute, понятно) — дает еще экономиии 1.0-1.8 секунды
                                                                                                                                            +8
                                                                                                                                            # echo быстрее, чем print

                                                                                                                                            Спасибо, вы раскрыли причину тормозов Друпала! :-)
                                                                                                                                              +3
                                                                                                                                              а еще echo экономит время программиста — надо набрать четыре буквы, а не пять.
                                                                                                                                              0
                                                                                                                                              show full processlist сам по себе стоит в сто раз дороже чем все эти советы вместе взятые
                                                                                                                                                +4
                                                                                                                                                Мне кажется, что совет «Не делайте запросы в цикле» полезнее всей этой статьи :)
                                                                                                                                                  +5
                                                                                                                                                  Многие советы никакой пользы не несут, некоторые вредные. Похоже на советы для говно-кодеров…

                                                                                                                                                  Не написано даже банальное, что надо писать чистый код и без собак, потому что на генерацию и подавление ошибок тратиться время.
                                                                                                                                                    +1
                                                                                                                                                    x = sizeOf($array); for($i = 0; $i < x; ++$i) {...} быстрее, чем for($i = 0; $i < sizeOf($array); ++$i) {...}

                                                                                                                                                    Скажу по секрету, что по-человечески это записывается так:
                                                                                                                                                    for ($i = 0, $l = sizeOf($array); $i < $l; $i++) {...}


                                                                                                                                                      0
                                                                                                                                                      $_SERVER[’REQUEST_TIME’] быстрее, чем time() для определения времени запуска скрипта
                                                                                                                                                      Причина в том, что в первом случае нет использования функции.

                                                                                                                                                      А как ты причину выяснил? Наугад что ли? Настоящая причина этого в том, что если использовать $_SERVER[’REQUEST_TIME’], то обращение к системному таймеру ОС идет один раз, а в случае time() — при каждом вызове.
                                                                                                                                                        0
                                                                                                                                                        Серьезно?! И в какой момент оно идёт?
                                                                                                                                                          0
                                                                                                                                                          Перед исполнением PHP-скипта.
                                                                                                                                                            0
                                                                                                                                                            Так может корректнее написать «то обращение к системному таймеру ОС идет один раз, до выполнения PHP-скипта, а в случае time() — ещё и при каждом её вызове?

                                                                                                                                                            Но главное, почему я не люблю использовать time — даже первой строчкой в скрипте она может вернуть время уже отличное от $_SERVER[’REQUEST_TIME’]
                                                                                                                                                        +5
                                                                                                                                                        return быстрее, чем global при возвращении значения переменной из функции
                                                                                                                                                        Это вызвано тем, что во втором случае создаётся глобальная переменная.

                                                                                                                                                        Кто-то возвращает данные из функции через global? Серьезно?
                                                                                                                                                          +1
                                                                                                                                                          автор, как видите. коллега, давайте поплачем вместе.
                                                                                                                                                          +1
                                                                                                                                                          Вы что серьёзно хотите повысить быстродействие современного веб-приложения советами типо "++i быстрее, чем i++"? Узкое место большинства веб-приложения — это запросы к бд, а использование кешеров (APC, xcache и т.д.) и перевод хотя бы части данных из СУБД в Redis или Memcache увеличит быстродействие в 100500 раз больше, по сравнению с тем, что Вы советуете.
                                                                                                                                                            +2
                                                                                                                                                            Когда быдлокодер хочет выглядеть умным, он начинает экономить на спичках и называет это оптимизацией.
                                                                                                                                                            0
                                                                                                                                                            Попробую сформулировать общие правила.

                                                                                                                                                            Операции получения данных в PHP, упорядоченные по скорости:
                                                                                                                                                            1. Чтение данных из памяти (поэтому можно кешировать данные даже в процессе выполнения одной страницы, другими словами никогда не читать из БД/файлов одно и то же дважды).
                                                                                                                                                            2. Чтение массива из файла (все статичные данные, по которым не надо вести сложный поиск, следует писать в php-файлы в виде массивов и подгружать их через include по необходимости).
                                                                                                                                                            3. Чтение из БД (СУБД сама оптимизирует — что в памяти, а что в файлах), если БД не перегружена. При большом количестве пользователей лучше несколько мелких запросов, чем один сложный (чтобы не создавать длинных очередей).
                                                                                                                                                            4. Чтение и интерпретация файлов (XML must die).

                                                                                                                                                            Это базовая оптимизация. Основные задержки идут при запросах к БД, так что оптимизировать надо в первую очередь их. И всегда использовать файловый (или в памяти) кеш (хотя бы и со временем жизни в 5 секунд), если отображение «живых» данных не критично.
                                                                                                                                                              +2
                                                                                                                                                              require быстрее, чем include для интерпретируемых файлов

                                                                                                                                                              ну, на сколько я понял из исходников, это одно и то же :)
                                                                                                                                                                +7
                                                                                                                                                                Вы не понимаете сути оптимизации!!!!1 Надо попробовать вызвать каждую функцию стотысяч раз и замерить на мобильнике секундомером время, а потом — сравнить!
                                                                                                                                                                  +3
                                                                                                                                                                  у меня мобильник только поминутно считает :)
                                                                                                                                                                    +2
                                                                                                                                                                    А у меня есть даже миллисекунды, давайте соберемся большой толпой и пропрофилируем!
                                                                                                                                                                      +3
                                                                                                                                                                      PHP Speed Test Busters Camp
                                                                                                                                                                      можно, чего б нет. пивко рыбка
                                                                                                                                                                      подключить к большому проектору вывод таймера
                                                                                                                                                                      можно замутить небольшой тотализатор :)
                                                                                                                                                                        +2
                                                                                                                                                                        Наймём профессионального комментатора, ведущего, несколько перерывов на рекламу
                                                                                                                                                                          +3
                                                                                                                                                                          и обязательно девочек в купальниках, которые будут носить выигрышное время и раунды на плакатах
                                                                                                                                                                0
                                                                                                                                                                Это не одно и то же, они одинаково подключают файлы, но есть один маленький нюанс: include, если не найдет файл бросает варнинг, require же фатал. Это единственная разница.
                                                                                                                                                                0
                                                                                                                                                                Прочитав уже первый совет про профилирование файрбагом в статье по оптимизации PHP все должно стать ясно.
                                                                                                                                                                  0
                                                                                                                                                                  Ну в файрбаге в принципе во вкладке «сеть» можно проанализировать все запросы к серверу, хэдэры запросов и ответов к серверу, время ответа сервера.
                                                                                                                                                                    0
                                                                                                                                                                    но если есть xdebug на сервере, то зачем? :)
                                                                                                                                                                      0
                                                                                                                                                                      Ну это так, заметка:) Не спорю что тут в целом бессмыслица
                                                                                                                                                                  –1
                                                                                                                                                                  У меня дежавю…

                                                                                                                                                                  Неужели кто-то еще не усвоил эти вещи?
                                                                                                                                                                    +3
                                                                                                                                                                    Я еще не усвоил, что ООП — это плохо :)
                                                                                                                                                                    0
                                                                                                                                                                    Ну вот, коллективный разум работает. Статья получилась какбэ не очень, зато в комментах помимо флуда написали уже много годных вещей.
                                                                                                                                                                      +2
                                                                                                                                                                      Статья бесполезна чуть более, чем полностью. Автор, не боитесь за свою профессиональную репутацию?
                                                                                                                                                                        +3
                                                                                                                                                                        Перенесите в «Юмор»
                                                                                                                                                                          0
                                                                                                                                                                          Не комментированный код быстрее, чем комментированный, так как уходит дополнительное время на чтение файла
                                                                                                                                                                          Весьма глупо уменьшать объём комментариев ради оптимизации, надо просто в рабочих («боевых») скриптах проводить минимизацию.

                                                                                                                                                                          Вспомнил бородатый прикол с баша о том что если убрать слово fuck из комментариев в исходниках Линукса, то они будут весить на 200мб меньше :)
                                                                                                                                                                            +5
                                                                                                                                                                            Отличный способ узнать что же реально влияет на скорость выполнения php — запостить статью про кавычки и ждать комментов.
                                                                                                                                                                              +7
                                                                                                                                                                              Шо, опять?


                                                                                                                                                                                0
                                                                                                                                                                                Берём кешер опкода, используем кэш, а сэкономленное на спичечной оптимизации время тратим на забрасывание помидорами авторов таких статей.

                                                                                                                                                                                >>readfile быстрее, чем file_get_contents, file_get_contents быстрее, чем require, а require быстрее, чем include

                                                                                                                                                                                убило, первая функция сразу бросает содержимое в буфер, вторая в переменную, третья для подключения php кода с ОСТАНОВКОЙ выполнения в случае его отсутствия, четвёртая тоже что третья, но скрипт продолжает работать с E_WARNING.
                                                                                                                                                                                  +1
                                                                                                                                                                                  Не говорите, непроизошедшая остановка куда быстрее непроизошедшего варнинга — далеко не всем это очевидно :)
                                                                                                                                                                                    0
                                                                                                                                                                                    дело не в скорости, а в их предназночении, отсутствие файла может повлиять на дальнейшую логику и если не отобряжённая часть шаблона ещё кое-как сойдёт, то подключив инклудом скрипт проверки прав можно схлопотать огромные проблемы.
                                                                                                                                                                                  +1
                                                                                                                                                                                  >>Использование сложных запросов к БД быстрее, чем использование нескольких простых
                                                                                                                                                                                  Разница во времени зависит от многих факторов (объём данных, настройка БД и пр.) и измеряется тысячными, а иногда даже сотыми, секунды.


                                                                                                                                                                                  Про то, что это совершенно неверная информация — уже написали и правильно.
                                                                                                                                                                                  Добавлю, что в большенстве случаев разбивка сложного запроса на более простые способная увеличить скорость выполнения в десятки раз. Это связано чаще всего с оптимизатором СУБД. В сособенности, когда в разделе WHERE пишут целые полотна для «зато всего одним запросом!»
                                                                                                                                                                                    –1
                                                                                                                                                                                    Ну я думаю автор имел ввиду нечто такое:

                                                                                                                                                                                    $result = query('SELECT `user_id` FROM users;');
                                                                                                                                                                                    $result = query('SELECT * FROM `user_profile` WHERE `user_id` IN ( ' . $result . ' )');
                                                                                                                                                                                    

                                                                                                                                                                                    Тогда да, безусловно один запрос будет быстрей чем эти два =)
                                                                                                                                                                                      +1
                                                                                                                                                                                      >>$result = query('SELECT * FROM `user_profile` WHERE `user_id` IN ( '. $result. ' )');

                                                                                                                                                                                      Вот сколько уже раз людям говорят, что нельзя после SELECT ставить звездочки! Это ужасно! Уж лучше тогда перечислить все поля таблицы будет в 10 раз дешевле запрос. И, уверен, все поля в итоге не нужны. Это так, помимо прочего.
                                                                                                                                                                                        –1
                                                                                                                                                                                        А Вас вообще не смутила конструкция IN ( '. $result. ' )? Ниче что эта конструкция вообще не рабочая? Да и вообще какие могут быть поля к гипотетическим таблицам? Мне что придумать Вам на ходу схему бд чтоб пример написать? Это так, помимо прочего.
                                                                                                                                                                                          +1
                                                                                                                                                                                          вот именно, чтобы небыло вот такого ответа, я и приписал в конфе коммента «Это так, помимо прочего. » :)
                                                                                                                                                                                          –1
                                                                                                                                                                                          «Уж лучше тогда перечислить все поля таблицы будет в 10 раз дешевле запрос»
                                                                                                                                                                                          Кстати, вот с этим я поспорил бы =) Если на то пошло.
                                                                                                                                                                                            +1
                                                                                                                                                                                            Ну вот, еще один… просто проверь
                                                                                                                                                                                              –2
                                                                                                                                                                                              SELECT * FROM и SELECT field1, field2… field_last FROM будут равны по скорости, для мускула узнать поля в таблице занимает ничтожно мало времени, это никак не влияет на запрос. Другое дело если выбираются не все поля а лишь парочка, тогда да, будет быстрей.
                                                                                                                                                                                                +2
                                                                                                                                                                                                еще раз — сначала проверь, иначе если я сам приведу примеры, вы будете выглядить не с лучшей стороны
                                                                                                                                                                                                  –2
                                                                                                                                                                                                  CREATE TABLE `users` (
                                                                                                                                                                                                    `user_id` int(10) unsigned NOT NULL AUTO_INCREMENT,
                                                                                                                                                                                                    `user_first_name` varchar(100) DEFAULT NULL,
                                                                                                                                                                                                    `user_last_name` varchar(100) DEFAULT NULL,
                                                                                                                                                                                                    `user_email` varchar(100) DEFAULT NULL,
                                                                                                                                                                                                    `user_phone` varchar(20) DEFAULT NULL,
                                                                                                                                                                                                    `user_birth_date` datetime DEFAULT NULL,
                                                                                                                                                                                                    `user_photo` varchar(255) DEFAULT NULL,
                                                                                                                                                                                                    `user_age` tinyint(4) DEFAULT NULL,
                                                                                                                                                                                                    PRIMARY KEY (`user_id`)
                                                                                                                                                                                                  ) ENGINE=MyISAM AUTO_INCREMENT=2289055 DEFAULT CHARSET=utf8
                                                                                                                                                                                                  
                                                                                                                                                                                                  
                                                                                                                                                                                                  SELECT COUNT(*) FROM users - 2289054
                                                                                                                                                                                                  
                                                                                                                                                                                                  SELECT * - 15,3 сек
                                                                                                                                                                                                  SELECT <перечислены все поля> - 16,1 сек
                                                                                                                                                                                                  


                                                                                                                                                                                                  Данные вбиты случайно, строки длиной от 5 до 10 символов, фото от 10 до 50 символов.
                                                                                                                                                                                                  заметы средние, делал по 5 раз. Винда семерка, настройки мускула дефолтные, машина рабочая, запущены всякие проги итд.

                                                                                                                                                                                                  Еще раз: для мускула узнать колонки — плевое дело, это не значительно влияет на запрос, больше влияют кривые руки тех кто делает запросы.
                                                                                                                                                                                                    0
                                                                                                                                                                                                    Берем БД стандартного dle (был под рукой). Берем самую его страшную табличку dle_post. Дабы не наглеть, limit 10000 (там миллионы кортежей) итого:

                                                                                                                                                                                                    from *: 10000 rows in set (1.39 sec)
                                                                                                                                                                                                    cols: 10000 rows in set (0.23 sec)

                                                                                                                                                                                                    mysql> select count(*) from dle_post: 11333792
                                                                                                                                                                                                      0
                                                                                                                                                                                                      Тоесть я выше от балды накидал циферок? Я привел реальный пример, реальной выборки.
                                                                                                                                                                                      0
                                                                                                                                                                                      Насчет
                                                                                                                                                                                      foreach ($arr as $key => $value) {...} быстрее, чем reset ($arr); while (list($key, $value) = each ($arr)) {...} для ассоциативных массивов
                                                                                                                                                                                      с экономией 0.00.....1 секунды все понятно, вопрос в другом (немного не по теме):
                                                                                                                                                                                      а что вообще движет людьми, которые до сих пор пишут второй вариант (с reset-while и т.п.)? Встречал таких несколько раз, и не так давно. Это ведь тупо больше кода (и больше языковых конструкций) при аналогичном результате. Привычка из бородатых времен или оплата за кол-во символов? :)
                                                                                                                                                                                        +1
                                                                                                                                                                                        Вы не понимаете, они оптимизируют свой код по максимуму!
                                                                                                                                                                                          0
                                                                                                                                                                                          Из бородатых времен… Сейчас в любом случае foreach будет быстрее (вот облом, ага).
                                                                                                                                                                                          0
                                                                                                                                                                                          Не вводите в заблуждение людей по поводу strtr и str_replace — это сильно разные функции.
                                                                                                                                                                                          Причем первая предназначена для «трансляции» символов, которые по доброте душевной расширили до «коротких слов».

                                                                                                                                                                                          На заменах слов внутри больших текстов strtr работает до 50 раз медленнее чем str_replace!

                                                                                                                                                                                          У меня шаблонизатор, уже 10 лет как на str_replace. Постоянно ищу более быструю замену, по мере выхода версий, но не нахожу ничего, кроме возможности написания отдельного модуля. Для подстановок, быстрее str_replace только sprintf, с предсказуемым порядком следования. Но это уже совсем из другой оперы.
                                                                                                                                                                                            0
                                                                                                                                                                                            Ну чего же вы, ведь с помошью strtr можно заменять слова =)
                                                                                                                                                                                            0
                                                                                                                                                                                            " ++i быстрее, чем i++ " выражение ++i и i++ это не одно,

                                                                                                                                                                                            $a = 0;
                                                                                                                                                                                            $b = ++a;
                                                                                                                                                                                            echo $b; // 1

                                                                                                                                                                                              0
                                                                                                                                                                                              (не дописал, сорри)
                                                                                                                                                                                              а следующий вариант возвращает 0
                                                                                                                                                                                              $a = 0;
                                                                                                                                                                                              $b = $a++;
                                                                                                                                                                                              echo $b; // 0
                                                                                                                                                                                              0
                                                                                                                                                                                              Статья — по сути тупо собранные воедино советы из кучи статей лохматых годов и времен PHP4.

                                                                                                                                                                                              Помню, при прочтении одной из таких статей ради интереса написал пару тестов и получил результаты, прямо противоречащие указанным советам.
                                                                                                                                                                                              Например, foreach() быстрее даже на массивах с идущими по порядку числовыми индексами, чем for (;;).

                                                                                                                                                                                              Впрочем, вышекомментящие уже верно отписали — смысла сидеть и оптимизировать php код такими оптимизациями (даже не outdated) — смысла не имеет, т.к. все скорее всего упрется в доступ к БД или в архитектуру всей системы.
                                                                                                                                                                                                0
                                                                                                                                                                                                print всё таки быстрее echo и этот факт стоит учитывать скажем в цикле выводя что-то.
                                                                                                                                                                                                А красиво сделанная разметка нужна в первую очередь не для скорости, а для того, чтобы можно было понять что вообще написано.
                                                                                                                                                                                                А то есть много уникумов (которые понаставят мне за это минусов), которые вместо того, чтобы думать о том, что этот код возможно будет кто-то править или смотреть, набивают по 4-5 пробелов где можно поставить табуляцию, или лепят всё в одну строчку, словно пишут шифровку в штаб, чтобы никто не догадался и потом приходится тратить долгое время, чтобы привести код в более-менее читабельный вид…
                                                                                                                                                                                                  0
                                                                                                                                                                                                  Отлично. Некоторые данные, правда, устарели, но все же!
                                                                                                                                                                                                    0
                                                                                                                                                                                                    Опять же, быстрее писать сервер на ассемблере, чем на PHP, но жизни не хватит :).
                                                                                                                                                                                                    За статью ГРАМАДНЕЙШЕЕ спасибо. Пишу пректик для себя, очень озабочен оптимизацией. Даже весь конфиг в массиве о_о.

                                                                                                                                                                                                    Only users with full accounts can post comments. Log in, please.