Производительность foreach, array_map с лямбдой и array_map со статической функцией


144

Какая разница в производительности (если есть) между этими тремя подходами, которые используются для преобразования массива в другой массив?

  1. С помощью foreach
  2. Использование array_mapс лямбда / функцией закрытия
  3. Использование array_mapсо «статической» функцией / методом
  4. Есть ли другой подход?

Чтобы прояснить ситуацию, давайте посмотрим на примеры, которые все делают одинаково - умножая массив чисел на 10:

$numbers = range(0, 1000);

Для каждого

$result = array();
foreach ($numbers as $number) {
    $result[] = $number * 10;
}
return $result;

Карта с лямбдой

return array_map(function($number) {
    return $number * 10;
}, $numbers);

Карта со статической функцией, переданная как строковая ссылка

function tenTimes($number) {
    return $number * 10;
}
return array_map('tenTimes', $numbers);

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


10
Почему бы вам не просто проверить и посмотреть, что происходит?
Джон

17
Ну, я могу сделать тест. Но я до сих пор не знаю, как это работает внутри. Даже если я узнаю, что один из них быстрее, я все равно не знаю, почему. Это из-за версии PHP? Это зависит от данных? Есть ли разница между ассоциативными и обычными массивами? Конечно, я могу сделать целый набор тестов, но получение некоторой теории экономит здесь много времени. Я надеюсь, вы понимаете ...
Павел С.

2
Поздний комментарий, но не так ли (список ($ k, $ v) = каждый ($ массив)) быстрее, чем все вышеперечисленное? Я не тестировал это в php5.6, но это было в более ранних версиях.
Оуэн Бересфорд

Ответы:


121

FWIW, я просто сделал тест, так как плакат не сделал этого. Работает на PHP 5.3.10 + XDebug.

ОБНОВЛЕНИЕ 2015-01-22 сравните с ответом mcfedr ниже для дополнительных результатов без XDebug и более поздней версии PHP.


function lap($func) {
  $t0 = microtime(1);
  $numbers = range(0, 1000000);
  $ret = $func($numbers);
  $t1 = microtime(1);
  return array($t1 - $t0, $ret);
}

function useForeach($numbers)  {
  $result = array();
  foreach ($numbers as $number) {
      $result[] = $number * 10;
  }
  return $result;
}

function useMapClosure($numbers) {
  return array_map(function($number) {
      return $number * 10;
  }, $numbers);
}

function _tenTimes($number) {
    return $number * 10;
}

function useMapNamed($numbers) {
  return array_map('_tenTimes', $numbers);
}

foreach (array('Foreach', 'MapClosure', 'MapNamed') as $callback) {
  list($delay,) = lap("use$callback");
  echo "$callback: $delay\n";
}

Я получаю довольно последовательные результаты с числами 1М за дюжину попыток:

  • Foreach: 0,7 с
  • Карта при закрытии: 3,4 сек.
  • Карта по названию функции: 1,2 сек.

Предположим, что нечеткая скорость карты при закрытии была вызвана тем, что замыкание, возможно, оценивается каждый раз, я также тестировал так:


function useMapClosure($numbers) {
  $closure = function($number) {
    return $number * 10;
  };

  return array_map($closure, $numbers);
}

Но результаты идентичны, подтверждая, что закрытие оценивается только один раз.

2014-02-02 ОБНОВЛЕНИЕ: дамп кодов

Вот дампы кода операции для трех обратных вызовов. Первый useForeach():



compiled vars:  !0 = $numbers, !1 = $result, !2 = $number
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
  10     0  >   EXT_NOP                                                  
         1      RECV                                                     1
  11     2      EXT_STMT                                                 
         3      INIT_ARRAY                                       ~0      
         4      ASSIGN                                                   !1, ~0
  12     5      EXT_STMT                                                 
         6    > FE_RESET                                         $2      !0, ->15
         7  > > FE_FETCH                                         $3      $2, ->15
         8  >   OP_DATA                                                  
         9      ASSIGN                                                   !2, $3
  13    10      EXT_STMT                                                 
        11      MUL                                              ~6      !2, 10
        12      ASSIGN_DIM                                               !1
        13      OP_DATA                                                  ~6, $7
  14    14    > JMP                                                      ->7
        15  >   SWITCH_FREE                                              $2
  15    16      EXT_STMT                                                 
        17    > RETURN                                                   !1
  16    18*     EXT_STMT                                                 
        19*   > RETURN                                                   null

Тогда useMapClosure()


compiled vars:  !0 = $numbers
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
  18     0  >   EXT_NOP                                                  
         1      RECV                                                     1
  19     2      EXT_STMT                                                 
         3      EXT_FCALL_BEGIN                                          
         4      DECLARE_LAMBDA_FUNCTION                                  '%00%7Bclosure%7D%2Ftmp%2Flap.php0x7f7fc1424173'
  21     5      SEND_VAL                                                 ~0
         6      SEND_VAR                                                 !0
         7      DO_FCALL                                      2  $1      'array_map'
         8      EXT_FCALL_END                                            
         9    > RETURN                                                   $1
  22    10*     EXT_STMT                                                 
        11*   > RETURN                                                   null

и закрытие это вызывает:


compiled vars:  !0 = $number
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
  19     0  >   EXT_NOP                                                  
         1      RECV                                                     1
  20     2      EXT_STMT                                                 
         3      MUL                                              ~0      !0, 10
         4    > RETURN                                                   ~0
  21     5*     EXT_STMT                                                 
         6*   > RETURN                                                   null

тогда useMapNamed()функция:


compiled vars:  !0 = $numbers
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
  28     0  >   EXT_NOP                                                  
         1      RECV                                                     1
  29     2      EXT_STMT                                                 
         3      EXT_FCALL_BEGIN                                          
         4      SEND_VAL                                                 '_tenTimes'
         5      SEND_VAR                                                 !0
         6      DO_FCALL                                      2  $0      'array_map'
         7      EXT_FCALL_END                                            
         8    > RETURN                                                   $0
  30     9*     EXT_STMT                                                 
        10*   > RETURN                                                   null

и названная функция вызывается, _tenTimes():


compiled vars:  !0 = $number
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
  24     0  >   EXT_NOP                                                  
         1      RECV                                                     1
  25     2      EXT_STMT                                                 
         3      MUL                                              ~0      !0, 10
         4    > RETURN                                                   ~0
  26     5*     EXT_STMT                                                 
         6*   > RETURN                                                   null

Спасибо за оценки. Тем не менее, я хотел бы знать, почему есть такая разница. Это из-за накладных расходов на вызов функции?
Павел С.

4
Я добавил дампы кода операции в выпуске. Первое, что мы можем видеть, это то, что именованные функция и замыкание имеют абсолютно одинаковый дамп, и они вызываются через array_map практически одинаково, с одним исключением: вызов замыкания включает еще один код операции DECLARE_LAMBDA_FUNCTION, который объясняет, почему его использование немного медленнее, чем использование названной функции. Теперь, сравнивая цикл массива с вызовами array_map, все в цикле массива интерпретируется внутри строки без какого-либо вызова функции, что означает отсутствие контекста для push / pop, только JMP в конце цикла, что, вероятно, объясняет большую разницу ,
FGM

4
Я только что попробовал это, используя встроенную функцию (strtolower), и в этом случае на useMapNamedсамом деле быстрее, чем useArray. Мысль, которую стоит упомянуть.
Рассерженная шлюха

1
В lap, вы не хотите range()звонить выше первого микротайм-звонка? (Хотя, вероятно, незначительно по сравнению со временем для цикла.)
contrebis

1
@billynoah PHP7.x действительно намного быстрее. Было бы интересно увидеть коды операций, сгенерированные этой версией, особенно по сравнению с / без opcache, так как он выполняет много оптимизаций помимо кэширования кода.
FGM

232

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

Это скрипт FGM, запускаемый с использованием 5.6 с xdebug

ForEach   : 0.79232501983643
MapClosure: 4.1082420349121
MapNamed  : 1.7884571552277

Без xdebug

ForEach   : 0.69830799102783
MapClosure: 0.78584599494934
MapNamed  : 0.85125398635864

Здесь есть только очень небольшая разница между версиями foreach и closure.

Также интересно добавить версию с закрытием use

function useMapClosureI($numbers) {
  $i = 10;
  return array_map(function($number) use ($i) {
      return $number * $i++;
  }, $numbers);
}

Для сравнения добавлю:

function useForEachI($numbers)  {
  $result = array();
  $i = 10;
  foreach ($numbers as $number) {
    $result[] = $number * $i++;
  }
  return $result;
}

Здесь мы можем видеть, что это влияет на версию закрытия, тогда как массив заметно не изменился.

19/11/2015 Я также добавил результаты, используя PHP 7 и HHVM для сравнения. Выводы похожи, хотя все гораздо быстрее.

PHP 5.6

ForEach    : 0.57499806880951
MapClosure : 0.59327731132507
MapNamed   : 0.69694859981537
MapClosureI: 0.73265469074249
ForEachI   : 0.60068697929382

PHP 7

ForEach    : 0.11297199726105
MapClosure : 0.16404168605804
MapNamed   : 0.11067249774933
MapClosureI: 0.19481580257416
ForEachI   : 0.10989861488342

HHVM

ForEach    : 0.090071058273315
MapClosure : 0.10432276725769
MapNamed   : 0.1091267824173
MapClosureI: 0.11197068691254
ForEachI   : 0.092114186286926

2
Я объявляю вас победителем, разорвав галстук и предоставив вам 51-й голос. ОЧЕНЬ важно убедиться, что тест не меняет результаты! Вопрос, однако, ваши времена результата для "Массива" являются методом цикла foreach, верно?
Баттл Буткус

2
Отличный респон. Приятно видеть, как быстро 7. Должен начать использовать его в свое личное время, еще на 5,6 на работе.
Дан

1
Так почему же мы должны использовать array_map вместо foreach? Зачем его добавлять в PHP, если он плохо работает? Есть ли какое-то конкретное условие, которое требует array_map вместо foreach? Есть ли какая-то конкретная логика, которую не может обработать foreach и array_map?
HendraWD

3
array_map(и связанная с ним функция array_reduce, array_filter) позволяет писать красивый код. Если array_mapбыло бы намного медленнее, это было бы причиной для использования foreach, но это очень похоже, поэтому я буду использовать array_mapвезде, где это имеет смысл.
МакФедр

3
Приятно видеть, что PHP7 значительно улучшен. Собирался перейти на другой бэкэнд-язык для моих проектов, но я буду придерживаться PHP.
Realnsleo

8

Это интересно. Но я получил противоположный результат со следующими кодами, которые упрощены из моих текущих проектов:

// test a simple array_map in the real world.
function test_array_map($data){
    return array_map(function($row){
        return array(
            'productId' => $row['id'] + 1,
            'productName' => $row['name'],
            'desc' => $row['remark']
        );
    }, $data);
}

// Another with local variable $i
function test_array_map_use_local($data){
    $i = 0;
    return array_map(function($row) use ($i) {
        $i++;
        return array(
            'productId' => $row['id'] + $i,
            'productName' => $row['name'],
            'desc' => $row['remark']
        );
    }, $data);
}

// test a simple foreach in the real world
function test_foreach($data){
    $result = array();
    foreach ($data as $row) {
        $tmp = array();
        $tmp['productId'] = $row['id'] + 1;
        $tmp['productName'] = $row['name'];
        $tmp['desc'] = $row['remark'];
        $result[] = $tmp;
    }
    return $result;
}

// Another with local variable $i
function test_foreach_use_local($data){
    $result = array();
    $i = 0;
    foreach ($data as $row) {
        $i++;
        $tmp = array();
        $tmp['productId'] = $row['id'] + $i;
        $tmp['productName'] = $row['name'];
        $tmp['desc'] = $row['remark'];
        $result[] = $tmp;
    }
    return $result;
}

Вот мои данные тестирования и коды:

$data = array_fill(0, 10000, array(
    'id' => 1,
    'name' => 'test',
    'remark' => 'ok'
));

$tests = array(
    'array_map' => array(),
    'foreach' => array(),
    'array_map_use_local' => array(),
    'foreach_use_local' => array(),
);

for ($i = 0; $i < 100; $i++){
    foreach ($tests as $testName => &$records) {
        $start = microtime(true);
        call_user_func("test_$testName", $data);
        $delta = microtime(true) - $start;
        $records[] = $delta;
    }
}

// output result:
foreach ($tests as $name => &$records) {
    printf('%.4f : %s '.PHP_EOL, 
              array_sum($records) / count($records), $name);
}

Результат:

0.0098: массив_карт
0.0114: foreach
0.0114: array_map_use_local
0.0115: foreach_use_local

Мои тесты были в производственной среде LAMP без xdebug. Я бродил xdebug, чтобы замедлить производительность array_map.


Не уверен, что у вас были проблемы с чтением ответа @mcfedr, но он ясно объясняет, что XDebug действительно замедляется array_map;)
igorsantos07

У меня есть тестирование производительности array_mapи foreachиспользование Xhprof. И это интересно array_mapпотребляет больше памяти, чем `foreach`.
Гопал Джоши
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.