Leistung von foreach, array_map mit lambda und array_map mit statischer Funktion

Was ist der performance-Unterschied (falls es welche gibt) zwischen diesen drei Ansätzen, die beide zum umwandeln eines Arrays einem anderen array?

Mit foreach
Mit array_map mit lambda/closure-Funktion
Mit array_map mit 'static' - Funktion/- Methode
Gibt es einen anderen Ansatz?

Machen mir klar, wir haben Blick auf die Beispiele, die alle das gleiche tun - die Multiplikation des array von zahlen von 10:

$numbers = range(0, 1000);

Foreach

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

Map mit lambda

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

Karte mit 'static' - Funktion als string übergeben Referenz

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

Gibt es einen anderen Ansatz? Ich werde glücklich sein, zu hören, eigentlich alle Unterschiede zwischen den Fällen von oben, und alle Eingänge, warum sollte man statt des anderen.

Warum gehst du nicht einfach benchmark, und sehen, was passiert?
Gut, ich kann einen benchmark. Aber ich weiß immer noch nicht, wie es intern funktioniert. Auch wenn ich finden Sie heraus, ist schneller, ich weiß immer noch nicht, warum. Ist es, weil der PHP-version? Kommt es auf die Daten? Gibt es einen Unterschied zwischen assoziativen und gewöhnliche arrays? Kann ich natürlich machen ganze suite von benchmarks aber immer einige Theorie spart hier eine Menge Zeit. Ich hoffe, Sie verstehen...
Verspäteter Kommentar, aber nicht while( list($k, $v)= each($array)) schneller als alle der oben genannten? Ich habe nicht gemessen, dieses in php5.6 aber es war in früheren Versionen.

InformationsquelleAutor Pavel S. | 2013-08-09

102

FWIW, ich habe gerade die benchmark, da die poster nicht. Läuft auf PHP 5.3.10 + XDebug.

UPDATE 2015-01-22 vergleichen mit mcfedr Antwort unten für weitere Ergebnisse, ohne XDebug und eine neuere PHP-version.


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

Ich bekomme ziemlich konsistente Ergebnisse mit 1M zahlen über ein Dutzend versuche:

Foreach: 0,7 sec
Karte auf Schließung: 3.4 Sek.
Karte auf der Funktion-name: 1.2 Sek.

Angenommen, dass der mäßigen Geschwindigkeit der Karte auf Schließung wurde verursacht durch die Schließung möglicherweise ausgewertet werden jedes mal, habe ich auch getestet, wie diese:


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

  return array_map($closure, $numbers);
}

Aber die Ergebnisse sind identisch, die bestätigt, dass die Schließung wird nur einmal ausgewertet.

2014-02-02-UPDATE: opcodes dump

Hier sind die opcode-dumps für die drei Rückrufe. Erste 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

Dann die 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

sowie die Schließung ruft es:


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

dann die useMapNamed() Funktion:


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

und die angegebene Funktion ruft es, _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

Danke für die benchmarks. Allerdings würde ich gerne wissen, warum es diesen Unterschied. Ist es, weil von einem Funktionsaufruf-overhead?
Ich habe den opcode steckt in der Frage. Erste, was wir sehen können ist, dass der benannte Funktion und Verschluss sind genau die gleichen dump, und Sie sind aufgerufen, per array_map in viel die gleiche Weise, mit nur einer Ausnahme: der closure-Aufruf enthält eine weitere opcode DECLARE_LAMBDA_FUNCTION, die erklärt, warum es ist ein bisschen langsamer als die benannte Funktion. Nun, der Vergleich der array-Schleife array_map vs fordert, alles, was in der array-Schleife interpretiert, inline, ohne Aufruf einer Funktion, was bedeutet, kein Zusammenhang von push/pop, nur einen JMP am Ende der Schleife, die wahrscheinlich erklärt den großen Unterschied.
Ich habe gerade versucht dies mit einer built-in-Funktion (strtolower), und in diesem Fall useMapNamed ist tatsächlich schneller als useArray. Dachte, das war erwähnenswert.
In lap, wollen Sie nicht die range() Anruf über die erste microtime nennen? (Obwohl wahrscheinlich unbedeutend im Vergleich mit der Zeit für die Schleife.)
PHP7.x ist so viel schneller, in der Tat. Es wäre interessant zu sehen, die opcodes generiert diese version, vor allem den Vergleich mit/ohne opcache, da es eine Menge an Optimierungen neben code-caching.

InformationsquelleAutor FGM

202

Seine interessante, die zur Ausführung dieser benchmark mit xdebug deaktiviert, da xdebug fügt sehr viel Aufwand, esp-Funktion aufruft.

Dies ist FGM ' s Skript ausführen, verwenden 5.6
Mit xdebug
```
ForEach   : 0.79232501983643
MapClosure: 4.1082420349121
MapNamed  : 1.7884571552277
```
Ohne xdebug
```
ForEach   : 0.69830799102783
MapClosure: 0.78584599494934
MapNamed  : 0.85125398635864
```
Hier gibt es nur einen sehr kleinen Unterschied zwischen foreach und Verschluss-version.

Es ist auch interessant zu fügen, eine version mit einem Verschluss mit einem use
```
function useMapClosureI($numbers) {
  $i = 10;
  return array_map(function($number) use ($i) {
      return $number * $i++;
  }, $numbers);
}
```
Zum Vergleich füge ich hinzu:
```
function useForEachI($numbers)  {
  $result = array();
  $i = 10;
  foreach ($numbers as $number) {
    $result[] = $number * $i++;
  }
  return $result;
}
```
Hier können wir sehen, es macht einen Einfluss auf die Verschluss-version, in der Erwägung, dass der array noch nicht merklich verändert.

19/11/2015 habe ich jetzt auch Hinzugefügt, Ergebnisse mit PHP 7 und HHVM für den Vergleich. Die Schlussfolgerungen sind ähnlich, obwohl alles viel schneller.
```
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
```
Vielen Dank für dein update! +1
Ich erkläre Euch zum Sieger durch das brechen der Band und geben Sie die 51st upvote. SEHR wichtig, um sicherzustellen, dass der test keinen Einfluss auf die Ergebnisse! Frage, obwohl, dein Ergebnis mal nach "Array" sind die foreach-loop-Methode, richtigen?
Ausgezeichnete Antwort. Schön zu sehen, wie schnell 7 ist. Gotta beginnen, es auf meine persönliche Zeit, die noch am 5.6 bei der Arbeit.
array_map (und die zugehörigen Funktionen array_reduce, array_filter) lassen Sie schreiben, schönen code. Wenn array_map war viel langsamer wäre es ein Grund für die Verwendung foreach, aber seine sehr ähnlich, also werde ich array_map überall dort, wo es Sinn macht.
Schön zu sehen, PHP7 erheblich verbessert. War etwa der Wechsel zu einem anderen backend-Sprache für meine Projekte, aber ich werde den stick zu PHP.

InformationsquelleAutor mcfedr

Ist es interessant. Aber ich habe ein gegenteiliges Ergebnis mit den folgenden codes, die vereinfacht aus meiner aktuellen Projekte:

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

Hier ist mein Test-Daten und 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);
}

Ist das Ergebnis:

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

Meine tests waren in der LAMPE Produktionsumgebung ohne xdebug.
Ich bin wandernden xdebug verlangsamen würde array_map Leistung.

Nicht sicher, wenn Sie hatte die Mühe das zu Lesen @mcfedr Antwort, aber er erklärt eindeutig, dass XDebug in der Tat verlangsamt array_map 😉
Ich habe testen der Leistung von array_map und foreach mit Xhprof. Und Seine interessante array_map verbraucht mehr Speicher als ` foreach`.

InformationsquelleAutor Clarence

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.