Prestazioni di foreach, array_map con lambda e array_map con funzione statica

Qual è la differenza di prestazioni (se presente) tra questi tre approcci, entrambi utilizzati per trasformare un array in un altro array?

1. utilizzando foreach
2. Utilizzo array_mapcon funzione lambda / chiusura
3. Utilizzo array_mapcon la funzione / metodo "statico"
4. C'è qualche altro approccio?

Per chiarirmi, diamo un'occhiata agli esempi, facendo tutti lo stesso, moltiplicando l'array di numeri per 10:

$numbers = range(0, 1000);

Per ciascuno

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

Mappa con lambda

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

Mappa con funzione 'statica', passata come riferimento di stringa

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

C'è qualche altro approccio? Sarò felice di sentire in realtà tutte le differenze tra i casi dall'alto e qualsiasi input sul perché uno dovrebbe essere usato al posto degli altri.

FWIW, ho appena fatto il benchmark dal momento che poster non lo ha fatto. In esecuzione su PHP 5.3.10 + XDebug.

AGGIORNAMENTO 2015-01-22 confronta con la risposta di mcfedr di seguito per ulteriori risultati senza XDebug e una versione PHP più recente.

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";
}

Ottengo risultati abbastanza coerenti con numeri 1M in una dozzina di tentativi:

• Foreach: 0,7 sec
• Mappa alla chiusura: 3,4 sec
• Mappa sul nome della funzione: 1,2 sec.

Supponendo che la scarsa velocità della mappa alla chiusura sia stata causata dalla possibilità di valutare ogni volta la chiusura, ho anche testato in questo modo:

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

  return array_map($closure, $numbers);
}

Ma i risultati sono identici, confermando che la chiusura viene valutata una sola volta.

02-02-2014 AGGIORNAMENTO: dump dei codici operativi

Ecco i dump del codice operativo per i tre callback. Primo 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

Poi il 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

e la chiusura che chiama:

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

quindi la useMapNamed()funzione:

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

e la funzione denominata chiama, _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

È interessante eseguire questo benchmark con xdebug disabilitato, poiché xdebug aggiunge un sacco di overhead, specialmente alle chiamate di funzione.

Questo è lo script di FGM eseguito usando 5.6 With xdebug

ForEach   : 0.79232501983643
MapClosure: 4.1082420349121
MapNamed  : 1.7884571552277

Senza xdebug

ForEach   : 0.69830799102783
MapClosure: 0.78584599494934
MapNamed  : 0.85125398635864

Qui c'è solo una piccolissima differenza tra la versione foreach e quella di chiusura.

È anche interessante aggiungere una versione con una chiusura con a use

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

Per confronto aggiungo:

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

Qui possiamo vedere che ha un impatto sulla versione di chiusura, mentre l'array non è notevolmente cambiato.

19/11/2015 Ho anche aggiunto i risultati usando PHP 7 e HHVM per il confronto. Le conclusioni sono simili, sebbene tutto sia molto più veloce.

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

È interessante. Ma ho un risultato opposto con i seguenti codici che sono semplificati dai miei progetti attuali:

// 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;
}

Ecco i miei dati e codici di test:

$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);
}

Il risultato è:

0.0098: array_map
0.0114: foreach
0.0114: array_map_use_local
0.0115: foreach_use_local

I miei test erano in ambiente di produzione LAMP senza xdebug. Sono un xdebug errante che rallenterebbe le prestazioni di array_map.