foreach、lambdaを使用したarray_map、static関数を使用したarray_mapのパフォーマンス

144

配列を別の配列に変換するために使用されるこれら3つのアプローチのパフォーマンスの違いは（ある場合）何ですか？

  1. 使用する foreach
  2. array_mapラムダ/クロージャー機能で使用する
  3. array_map「静的」関数/メソッドで使用する
  4. 他のアプローチはありますか？

私自身を明確にするために、例を見てみましょう。すべて同じことを行います-数値の配列に10を乗算します。

$numbers = range(0, 1000);

Foreach

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

他のアプローチはありますか？私は実際に上記のケース間のすべての違いを聞いて喜んでいます、そしてなぜ他のものの代わりに使用されるべきであるかについてのインプット。

php  performance  foreach  lambda  array-map 
— パベル・S
ソース
10
ベンチマークをして、何が起こるか見てみませんか？
— Jon
17
まあ、私はベンチマークを作るかもしれません。しかし、それが内部でどのように機能するかはまだわかりません。どちらかが速いとわかっても、その理由はわかりません。PHPのバージョンが原因ですか？データに依存しますか？連想配列と通常の配列に違いはありますか？もちろん、一連のベンチマークを作成できますが、理論を理解することで、時間を大幅に節約できます。私は...あなたが理解してほしい
— パベルS.
2
遅いコメントですが、while（list（$ k、$ v）= each（$ array））は上記のすべてよりも速くありませんか？私はこれをphp5.6でベンチマークしていませんが、それは以前のバージョンにありました。
— オーウェンベレスフォード2015

回答:

121

FWIW、ポスターがそれをしなかったので、私はちょうどベンチマークをしました。PHP 5.3.10 + XDebugで実行します。

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

数十回の試行で100万の数値を使用して、かなり一貫した結果が得られます。

  • Foreach：0.7秒
  • 閉鎖時の地図：3.4秒
  • 関数名のマップ：1.2秒。

クロージャーでのマップの速度が遅いのは、クロージャーが毎回評価される可能性があるためと考えられ、次のようにテストしました。


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

  return array_map($closure, $numbers);
}

しかし、結果は同じであり、クロージャは一度しか評価されないことが確認されています。

2014-02-02 UPDATE：オペコードダンプ

以下は、3つのコールバックのオペコードダンプです。まず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
— FGM
ソース
ベンチマークをありがとう。しかし、なぜそのような違いがあるのか​​知りたいのですが。関数呼び出しのオーバーヘッドが原因ですか？
— Pavel S.
4
問題にオペコードダンプを追加しました。最初にわかるのは、名前付き関数とクロージャのダンプがまったく同じであり、それらはarray_mapを介してほとんど同じ方法で呼び出されますが、例外が1つあります：クロージャの呼び出しには、オペコードDECLARE_LAMBDA_FUNCTIONが1つ含まれています名前付き関数を使用するよりも少し遅くなります。ここで、配列ループとarray_map呼び出しを比較すると、配列ループ内のすべてがインラインで解釈され、関数への呼び出しはありません。つまり、プッシュ/ポップするコンテキストがなく、ループの最後にJMPがあるだけなので、大きな違いが説明されます。 。
— FGM 2014
4
私は組み込み関数（strtolower）を使用してこれを試しましたが、その場合、useMapNamed実際にはよりも高速ですuseArray。言及する価値があったと思いました。
— DisgruntledGoat 2014
1
ではlap、range()最初のマイクロタイムコールよりも上のコールを希望しませんか？（おそらく、ループの時間と比較して取るに足らないものです。）
— contrebis '27年
1
@billynoah PHP7.xは、実にはるかに高速です。このバージョンで生成されたオペコードを見ると、コードキャッシュ以外にも多くの最適化が行われるため、特にopcacheの有無と比較すると興味深いでしょう。
— FGM 2017年
231

xdebugを無効にしてこのベンチマークを実行するのは興味深いことです。xdebugは、特に関数呼び出しにかなりのオーバーヘッドを追加します。

これは、xdebugで5.6を使用して実行されたFGMのスクリプトです

ForEach   : 0.79232501983643
MapClosure: 4.1082420349121
MapNamed  : 1.7884571552277

xdebugなし

ForEach   : 0.69830799102783
MapClosure: 0.78584599494934
MapNamed  : 0.85125398635864

ここでは、foreachバージョンとクロージャーバージョンの違いはごくわずかです。

クロージャー付きのバージョンを追加することも興味深いです 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;
}

ここでは、クロージャーのバージョンに影響を与えることがわかりますが、配列はそれほど変化していません。

2015/11/19比較のために、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
— mcfedr
ソース
2
引き分けで51番目の賛成票を投じ、勝者を宣言します。テストが結果を変更しないことを確認することは非常に重要です！質問、しかし、「配列」の結果時間はforeachループメソッドですよね？
— Buttle Butkus
2
優れた応答。7がどれほど速いか見てみましょう。Gottaは私の個人的な時間にそれを使い始めましたが、まだ5.6です。
— Dan
1
では、なぜforeachではなくarray_mapを使用する必要があるのでしょうか。パフォーマンスが悪いのになぜPHPに追加されたのですか？foreachの代わりにarray_mapが必要な特定の条件はありますか？foreachが処理できず、array_mapが処理できる特定のロジックはありますか？
— HendraWD 2017
3
array_map（およびその関連機能はarray_reduce、array_filter）あなたが美しいコードを書いてみましょう。array_mapはるかに遅い場合はを使用する理由になりますforeachが、非常に似array_mapているので、意味のあるすべての場所で使用します。
— mcfedr 2017
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：array_map
0.0114：foreach
0.0114：array_map_use_local
0.0115：foreach_use_local

私のテストは、xdebugのないLAMP実稼働環境で行われました。xdebugをさまようと、array_mapのパフォーマンスが低下します。

— クラレンス
ソース
@mcfedrの回答を読むのに問題があったかどうかはわかりませんが、XDebugが実際に遅くなることを明確に説明していますarray_map;）
— igorsantos07
Xhprofのパフォーマンスをテストarray_mapしてforeach使用しています。そして、興味深いのarray_mapは、 `foreach`よりも多くのメモリを消費することです。
— Gopal Joshi
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.