La Performance de foreach, array_map avec lambda et array_map avec fonction statique

Quelle est la différence de performances (si il y en a un) entre ces trois approches, à la fois utilisé pour transformer un tableau à un autre tableau?

  1. À l'aide de foreach
  2. À l'aide de array_map avec lambda/fermeture de la fonction
  3. À l'aide de array_map avec "statique" de la fonction/méthode
  4. Est-il une autre approche?

À me faire comprendre, voyons les exemples, tous font le même multipliant la matrice de nombres de 10:

$numbers = range(0, 1000);

Foreach

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

Carte avec lambda

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

Carte avec "statique" de la fonction, passé en tant que chaîne de référence

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

Est-il une autre approche? Je serai heureux d'entendre réellement tous différences entre les cas à partir de ci-dessus, et toutes les entrées pourquoi on devrait être utilisé à la place des autres.

  • Pourquoi ne pas vous venez de référence et de voir ce qui se passe?
  • Eh bien, je peut faire un test. Mais je ne sais toujours pas comment ça fonctionne en interne. Même si je trouve l'un est plus rapide, je ne sais toujours pas pourquoi. C'est à cause de la version de PHP? Cela dépend-il les données? Est-il une différence entre associatifs et de simples tableaux? Bien sûr, je peux faire toute suite de points de référence, mais l'obtention de certains théorie enregistre ici beaucoup de temps. J'espère que vous comprenez...
  • Fin de commentaire, mais ce n'est pas while( list($k, $v)= each($tableau)) plus rapide que tous les ci-dessus? Je n'ai pas comparé ce en php5.6, mais c'était dans les versions antérieures.
InformationsquelleAutor Pavel S. | 2013-08-09
  1. 104

    FWIW, je viens de faire le test depuis l'affiche n'a pas fait. En cours d'exécution sur PHP 5.3.10 + XDebug.

    Mise à JOUR 2015-01-22 comparer avec mcfedr la réponse ci-dessous pour des résultats sans XDebug et une plus récente version de 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";
}

    - Je obtenir de jolis résultats cohérents avec 1M numéros entre une douzaine de tentatives:

    • Foreach: 0.7 sec
    • Carte fermeture: 3,4 s
    • Carte sur le nom de la fonction: 1.2 sec.

    En supposant que l'atonie de la vitesse de la carte de la fermeture a été causé par la fermeture éventuellement être évalués à chaque fois, j'ai aussi testé comme ceci:

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

  return array_map($closure, $numbers);
}

    Mais les résultats sont identiques, confirmant que la fermeture n'est évaluée qu'une fois.

    2014-02-02 mise à JOUR: opcodes de vidage

    Voici l'opcode décharges pour les trois rappels. Première 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

    Puis le 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

    et de la fermeture il appelle:

    
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

    puis le useMapNamed() fonction:

    
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

    et le nom de la fonction qu'il appelle, _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
    • Merci pour les indices de référence. Cependant, je voudrais savoir pourquoi il y a une telle différence. Est-ce à cause d'un appel de fonction, les frais généraux?
    • J'ai ajouté de l'opcode les décharges en question. La première chose que nous pouvons voir, c'est que le nom de fonction et de fermeture ont exactement le même dump, et ils sont appelés par array_map de la même manière, à une exception près: la fermeture de l'appel comprend une plus opcode DECLARE_LAMBDA_FUNCTION, ce qui explique pourquoi il est un peu plus lent que d'utiliser le nom de fonction. Maintenant, en comparant le tableau boucle vs array_map appels, tout dans la boucle de tableau est interprété à la volée, sans aucun appel à une fonction, ce qui signifie qu'aucun contexte pour push/pop, juste un JMP à la fin de la boucle, ce qui explique sans doute la grande différence.
    • Je viens d'essayer ceci à l'aide d'une fonction intégrée (strtolower), et dans ce cas, useMapNamed est effectivement plus rapide que useArray. Pensé que c'était la peine de mentionner.
    • Dans lap, ne voulez-vous pas le range() appel ci-dessus, la première microtime appel? (Mais probablement insignifiant en comparaison avec le temps de la boucle.)
    • je ne sais pas pourquoi vous l'avez appelé "useArray" comme toutes les méthodes de travail sur un tableau. J'ai modifié pour "useForeach" car c'est ce qu'il fait vraiment.
    • juste couru exacte de ce code avec PHP 7.0.8 / Ubuntu 16.04.3 avec les résultats suivants: Foreach: 0.092797994613647, MapClosure: 0.094599008560181, MapNamed: 0.093489170074463.
    • PHP7.x est donc beaucoup plus rapide en effet. Il serait intéressant de voir les opcodes générés par cette version, surtout en comparant avec/sans opcache, car il fait beaucoup d'optimisations en outre le code de mise en cache.
    • Je n'ai aucune idée de la façon de générer des opcodes, mais je peux si vous voulez expliquer. J'ai été surtout surpris de voir que, bien que foreach est encore plus rapide, les trois méthodes ont réduit l'écart considérable au point d'en être presque identique à la vitesse.
    • vous pouvez utiliser 3v4l.org pour cela: eval le code, puis cliquez sur le VLD onglet.
    • Si vous réduisez la plage jusqu'à 10000, vous pouvez exécuter un tas de tests pour obtenir un plus à moyenne vitesse. J'ai également remarqué que le passage d'argument par référence semble raser quelques instants ainsi. Ensuite, il y a toujours la pour le compteur de la boucle de trop.

    InformationsquelleAutor FGM
  2. 206

    Son intéressant pour exécuter ce test avec xdebug désactivé, comme xdebug ajoute beaucoup de frais généraux, esp pour les appels de fonction.

    C'est MGF du script exécuté à l'aide de 5.6
    Avec xdebug

    ForEach   : 0.79232501983643
MapClosure: 4.1082420349121
MapNamed  : 1.7884571552277

    Sans xdebug

    ForEach   : 0.69830799102783
MapClosure: 0.78584599494934
MapNamed  : 0.85125398635864

    Ici il n'y a qu'une très petite différence entre le foreach et de fermeture de version.

    Il est aussi intéressant d'ajouter une version avec une fermeture avec un use

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

    Pour la comparaison, j'ai ajouté:

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

    Ici, nous pouvons voir qu'il a un impact sur la fermeture de la version, alors que le tableau n'a pas sensiblement changé.

    19/11/2015 j'ai aussi maintenant ajouté les résultats à l'aide de PHP 7 et HHVM à des fins de comparaison. Les conclusions sont similaires, si tout est beaucoup plus rapide.

    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
    • Merci pour votre mise à jour! +1
    • Je déclare que vous le gagnant par briser l'égalité et de vous donner la 51e upvote. TRÈS important de s'assurer que le test ne modifie pas les résultats! La Question, cependant, vos résultats pour "Tableau" sont la boucle foreach méthode, non?
    • Excellent respone. Agréable de voir comment rapide 7 est. Dois commencer à l'utiliser sur mon temps personnel, toujours à 5,6 au travail.
    • Alors pourquoi nous devons utiliser array_map au lieu de foreach? Pourquoi il ajouté en PHP si il est mauvais dans la performance? Est-il une condition spécifique qui a besoin de array_map au lieu de foreach? Est-il logique spécifique qui foreach ne peut pas gérer et array_map peut-il gérer?
    • array_map (et de ses fonctions array_reduce, array_filter) vous permettent d'écrire du code. Si array_map a été beaucoup plus lente, ce serait une raison d'utiliser foreach, mais son très similaire, donc je vais utiliser array_map partout où cela a du sens.
    • Agréable de voir PHP7 est grandement améliorée. Était sur le point de passer à un autre backend langue pour mes projets, mais je m'en tiendrai à PHP.
    • Code fonctionnel à l'aide de array_map est beaucoup plus facile à lire et à écrire, et le développeur du temps est beaucoup plus cher que les cycles de processeur. La lecture d'une boucle n'est pas difficile, mais il prend plus de temps pour réaliser que c'est juste faire une carte. Mieux vaut dire que l'avant jusqu'en appelant la fonction map.

    InformationsquelleAutor mcfedr
  3. 8

    C'est intéressant. Mais, j'ai obtenu un résultat inverse avec les codes suivants qui sont simplifiées à partir de mes projets en cours:

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

    Voici mon test, les données et les codes:

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

    Le résultat est:

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

    Mes tests ont été dans la LAMPE environnement de production sans xdebug.
    Je suis errant xdebug serait de ralentir array_map de la performance.

    • Vous ne savez pas si vous avez eu la peine de le lire @mcfedr réponse, mais il explique clairement que XDebug ralentit en effet la array_map 😉
    • J'ai tester les performances de array_map et foreach à l'aide de Xhprof. Et Son intéressante array_map consomme plus de mémoire que ` foreach`.
    InformationsquelleAutor Clarence