Я читал где-нибудь (я думал о кодировании), что это плохая практика, чтобы добавить строки вместе, как если бы они были числами, так как подобные числа строки не могут быть изменены. Таким образом, добавление их вместе создает новую строку. Итак, мне было интересно, что лучший способ добавить две строки вместе, когда сосредоточится на производительности?
Какой из этих четырех лучше, или есть другой способ, который лучше?
//Note that normally at least one of these two strings is variable $str1 = 'Hello '; $str2 = 'World!'; $output1 = $str1.$str2; //This is said to be bad $str1 = 'Hello '; $output2 = $str1.'World!'; //Also bad $str1 = 'Hello'; $str2 = 'World!'; $output3 = sprintf('%s %s', $str1, $str2); //Good? //This last one is probaply more common as: //$output = sprintf('%s %s', 'Hello', 'World!'); $str1 = 'Hello '; $str2 = '{a}World!'; $output4 = str_replace('{a}', $str1, $str2); Это даже имеет значение?
Вы всегда будете создавать новую цепочку, объединяющую две или более строки вместе. Это не обязательно «плохо», но оно может иметь последствия для производительности в определенных сценариях (например, в тысячах / миллионах конкатенаций в узком цикле). Я не парень PHP, поэтому я не могу дать вам никаких советов по семантике различных способов конкатенации строк, но для единственной конкатенации строк (или только нескольких) просто сделайте ее доступной для чтения. Вы не увидите хит производительности из-за их небольшого количества.
String Concatenation с точкой, безусловно, является самым быстрым из трех методов. Вы всегда будете создавать новую строку, нравится вам это или нет. Скорее всего, самый быстрый способ:
$str1 = "Hello"; $str1 .= " World";
Не помещайте их в двойные кавычки, как $result = "$str1$str2"; так как это создаст дополнительные накладные расходы для анализа символов внутри строки.
Если вы собираетесь использовать это только для вывода с эхом, используйте функцию эха, чтобы передать несколько параметров, поскольку это не приведет к созданию новой строки:
$str1 = "Hello"; $str2 = " World"; echo $str1, $str2;
Для получения дополнительной информации о том, как PHP обрабатывает интерполированные строки и конкатенацию строк, просмотрите блог Сары Големан .
Вот быстрый и грязный тестовый код, чтобы понять узкие места производительности.
$iterations = 1000000; $table = 'FOO'; $time = microtime(true); for ($i = 0; $i < $iterations; $i++) { $sql = sprintf('DELETE FROM `%s` WHERE `ID` = ?', $table); } echo 'single sprintf,',(microtime(true) - $time)."\n"; $time = microtime(true); for ($i = 0; $i < $iterations; $i++) { $sql = 'DELETE FROM `' . $table . '` WHERE `ID` = ?'; } echo 'single concat,',(microtime(true) - $time)."\n"; $time = microtime(true); for ($i = 0; $i < $iterations; $i++) { $sql = "DELETE FROM `$table` WHERE `ID` = ?"; } echo 'single "$str",',(microtime(true) - $time)."\n";
Я получаю следующие результаты:
single sprintf,0.66322994232178 single concat,0.18625092506409 <-- winner single "$str",0.19963216781616
$iterations = 1000000; $table = 'FOO'; $time = microtime(true); for ($i = 0; $i < $iterations; $i++) { $sql = sprintf('DELETE FROM `%s`,`%s`,`%s`,`%s`,`%s`,`%s`,`%s`,`%s`,`%s`,`%s` WHERE `ID` = ?', $table, $table, $table, $table, $table, $table, $table, $table, $table, $table); } echo 'many sprintf,',(microtime(true) - $time)."\n"; $time = microtime(true); for ($i = 0; $i < $iterations; $i++) { $sql = 'DELETE FROM `' . $table . '`,`' . $table . '`,`' . $table . '`,`' . $table . '`,`' . $table . '`,`' . $table . '`,`' . $table . '`,`' . $table . '`,`' . $table . '`,`' . $table . '` WHERE `ID` = ?'; } echo 'many concat,',(microtime(true) - $time)."\n"; $time = microtime(true); for ($i = 0; $i < $iterations; $i++) { $sql = "DELETE FROM `$table`,`$table`,`$table`,`$table`,`$table`,`$table`,`$table`,`$table`,`$table`,`$table` WHERE `ID` = ?"; } echo 'many "$str",',(microtime(true) - $time)."\n";
Результаты:
many sprintf,2.0778489112854 many concats,1.535336971283 many "$str",1.0247709751129 <-- winner
Как вывод, становится очевидным, что единственный concat через точку (.) Char является самым быстрым. И для случаев, когда у вас много конкатений, наилучшим образом используемым методом является использование прямой инъекции строк через синтаксис "injection: $inject" .
Если его действительно большой объем текста, это действительно не имеет значения.
Как говорили другие, $str1 . $str2 $str1 . $str2 отлично подходит для большинства случаев, за исключением (больших) циклов.
Обратите внимание, что вы пропускаете некоторые решения:
$output = "$str1$str2";
и для большого количества строк вы можете поместить их в массив и использовать implode (), чтобы получить из них строку.
О, и «добавление строк» звучит плохо или, по крайней мере, неоднозначно. В большинстве языков мы предпочитаем говорить о конкатенации строк.
Это не имеет значения, если не используется в петле looong. В обычных случаях основное внимание уделяется читаемости кода, даже если вы потеряли несколько процессорных циклов.
Пример 1 и 2 аналогичны, я не думаю, что должна быть большая разница, это были бы посты всех. № 1 может быть немного быстрее.
Пример 3 будет медленнее, так как формат sprintf ('% s% s') должен быть проанализирован.
В примере 4 замена, которая включает в себя поиск в строке – дополнительная вещь, требуется больше времени.
Но, во-первых, конкатенация строк связана с проблемой производительности? Это очень маловероятно, вы должны определить код, чтобы определить, сколько времени требуется для его запуска. Затем замените метод конкатенации на другой и снова.
Если вы идентифицируете его как проблему, попробуйте googling для класса php string builder (некоторые из них будут найдены) или напишите сами.
Нашел этот пост от Google и подумал, что я запустил некоторые тесты, так как мне было любопытно, каков будет результат. (Проведено более 10 000 итераций с использованием бенчмаркера, который вычитает свои собственные накладные расходы).
Какие 2 строки 10 строк 50 строк
-------------------------------------------------- --------------
$ a [] затем implode () 2728,20 пс 6,02 мкс 22,73 мкс
$ a. $ a. $ a 496,44 пс 1,48 мкс 7,00 мкс
$ b. = $ a 421,40 ps * 1,26 мкс 5,56 мкс
ob_start () и echo $ a 2278.16 пс 3.08 мкс 8.07 мкс
"$ a $ a $ a" 482,87 пс 1,21 мкс ★ 4,94 мкс ★
sprintf () 1543,26 пс 3,21 мкс 12,08 мкс
Так что в этом не так много. Вероятно, полезно избегать sprintf() и implode() если вам нужно что-то быстро кричать, но между всеми обычными методами нет большой разницы.
существует 3 типа операций объединения строк.
Объедините, возьмите 2 строки, выделите размер памяти length1 + length2 и скопируйте каждый в новую память. самый быстрый для 2 строк. Однако при объединении 10 строк требуется 9 операций concat. Используемая память – 1-я строка 10 раз, 2-я строка 10 раз, 3-я строка 9 раз, 4-я строка 8 раз и т. Д. Выполняет операции X + 1 + (X-1) * 2, используя больше памяти для каждого цикла.
sprintf (array_merge, join и т. д.), возьмите все строки вместе, суммируйте их длину, выделите новую строку суммы размера, затем скопируйте каждую строку в соответствующее место. используется 2 * длина всех начальных строк, а операции – 2 * X (каждая длина, каждая копия)
ob (выходной буфер) выделяет общий 4k-фрагмент и копирует в него каждую строку. память 4k + каждая начальная строка, операции = 2 + X. (начало, конец, каждая копия)
Выбрать свой яд. OB похож на использование атомной бомбы памяти, чтобы присоединиться к двум небольшим строкам, но очень эффективен, когда есть много соединений, циклов, условий или добавок слишком динамичны для чистого sprintf. concat – самый эффективный способ присоединиться к нескольким фиксированным строкам, sprintf, который работает лучше для построения строки из фиксированных значений за один раз.
Я не знаю, какая подпрограмма php использует в этой ситуации: «$ x $ y $ z», может быть просто сведена к встроенному $ x. "". $ y. "". $ г
Совет, который вы прочитали, возможно, был связан с функцией echo , для которой быстрее использовать запятые, например:
echo $str1, $str2;
Другой подход заключается в создании строки в переменной (например, с использованием оператора.), А затем эхо всей строки в конце.
Вы можете проверить это самостоятельно, используя функцию microtime (вам нужно сделать цикл, который повторяется, например, 1000 или 100 000 раз, чтобы сделать цифры значительными). Но из четырех вы отправили, первый, скорее всего, будет самым быстрым. Это также самое читаемое – другие не имеют смысла программно.
Это не решение для двух строк, но когда вы думаете о присоединении большего количества строк, лучший способ:
$tmp=srray(); for(;;) $tmp[]='some string'; $str=implode('',$tmp);
Быстрее создавать элемент массива и присоединяться к ним сразу, а не присоединяться к ним в сотни раз.
Однако я не PHP-гуру на многих других языках (например, Python), самый быстрый способ построить длинную строку из многих меньших строк – добавить строки, которые вы хотите объединить в список, а затем присоединиться к ним используя встроенный метод соединения. Например:
$result = array(); array_push("Hello,"); array_push("my"); array_push("name"); array_push("is"); array_push("John"); array_push("Doe."); $my_string = join(" ", $result);.$result = array(); array_push("Hello,"); array_push("my"); array_push("name"); array_push("is"); array_push("John"); array_push("Doe."); $my_string = join(" ", $result);
Если вы строите огромную строку в узком цикле, самый быстрый способ сделать это – добавить к массиву и затем присоединиться к массиву в конце.
Примечание. Вся эта дискуссия зависит от производительности массива array_push. Вы должны добавить свои строки в список, чтобы это было эффективным для очень больших строк. Из-за моего ограниченного воздействия на php я не уверен, доступна ли такая структура или массив php быстро добавляет новые элементы.
Почти 2 года после последнего сообщения в этой теме, я думаю, что ниже решение может быть самым быстрым для огромного количества жестких циклов:
ob_start(); echo $str1; echo $str2; . . . echo $str_n; $finalstr = ob_get_clean();
Этот метод обеспечивает плоское хранение всех строк и отсутствие обработки или конкатенации. С окончательной строкой кода вы также получаете весь буфер. Вы можете безопасно запускать циклы вместо независимых эхо.