web-dev-qa-db-ja.com

Ruby：Proc＃call vs yield

thriceメソッドのRuby=）の次の2つの実装の動作の違いは何ですか？

module WithYield
  def self.thrice
    3.times { yield }      # yield to the implicit block argument
  end
end

module WithProcCall
  def self.thrice(&block)  # & converts implicit block to an explicit, named Proc
    3.times { block.call } # invoke Proc#call
  end
end

WithYield::thrice { puts "Hello world" }
WithProcCall::thrice { puts "Hello world" }

「動作の違い」には、エラー処理、パフォーマンス、ツールサポートなどが含まれます。

rubyyield
74
Sam Stokes

最初のものは実際にはもう一方の構文糖衣だと思います。つまり、行動の違いはありません。

ただし、2番目の形式で許可されるのは、変数にブロックを「保存」することです。その後、他の時点でブロックを呼び出すことができます-コールバック。

OK。今回は、簡単なベンチマークを行ってみました：

require 'benchmark'

class A
  def test
    10.times do
      yield
    end
  end
end

class B
  def test(&block)
    10.times do
      block.call
    end
  end
end

Benchmark.bm do |b|
  b.report do
    a = A.new
    10000.times do
      a.test{ 1 + 1 }
    end
  end

  b.report do
    a = B.new
    10000.times do
      a.test{ 1 + 1 }
    end
  end

  b.report do
    a = A.new
    100000.times do
      a.test{ 1 + 1 }
    end
  end

  b.report do
    a = B.new
    100000.times do
      a.test{ 1 + 1 }
    end
  end

end

結果は興味深いです：

      user     system      total        real
  0.090000   0.040000   0.130000 (  0.141529)
  0.180000   0.060000   0.240000 (  0.234289)
  0.950000   0.370000   1.320000 (  1.359902)
  1.810000   0.570000   2.380000 (  2.430991)

これは、block.callの使用がyieldの使用よりもほぼ2倍遅いことを示しています。

50
jpastuszek

Ruby 2.xの更新です

Ruby 2.0.0p247（2013-06-27リビジョン41674）[x86_64-darwin12.3.0]

手動でベンチマークを書くのが面倒になったので、 benchable という小さなランナーモジュールを作成しました

require 'benchable' # https://Gist.github.com/naomik/6012505

class YieldCallProc
  include Benchable

  def initialize
    @count = 10000000    
  end

  def bench_yield
    @count.times { yield }
  end

  def bench_call &block
    @count.times { block.call }
  end

  def bench_proc &block
    @count.times &block
  end

end

YieldCallProc.new.benchmark

出力

                      user     system      total        real
bench_yield       0.930000   0.000000   0.930000 (  0.928682)
bench_call        1.650000   0.000000   1.650000 (  1.652934)
bench_proc        0.570000   0.010000   0.580000 (  0.578605)

ここで最も驚くべきことは、bench_yieldがbench_procより遅いことです。これがなぜ起こっているのか、もう少し理解していただけたらと思います。

9
user633183

他の答えはかなり徹底しており、 Rubyのクロージャー は機能の違いを広範囲にわたってカバーしています。 オプションでブロックを受け入れるメソッドにどのメソッドが最適かを知りたいので、ベンチマークを作成しました（ this Paul Mucur post ）。 3つの方法を比較しました。

  • メソッドシグネチャで＆block
  • &Proc.newを使用
  • yieldを別のブロックにラップする

コードは次のとおりです。

require "benchmark"

def always_yield
  yield
end

def sometimes_block(flag, &block)
  if flag && block
    always_yield &block
  end
end

def sometimes_proc_new(flag)
  if flag && block_given?
    always_yield &Proc.new
  end
end

def sometimes_yield(flag)
  if flag && block_given?
    always_yield { yield }
  end
end

a = b = c = 0
n = 1_000_000
Benchmark.bmbm do |x|
  x.report("no &block") do
    n.times do
      sometimes_block(false) { "won't get used" }
    end
  end
  x.report("no Proc.new") do
    n.times do
      sometimes_proc_new(false) { "won't get used" }
    end
  end
  x.report("no yield") do
    n.times do
      sometimes_yield(false) { "won't get used" }
    end
  end

  x.report("&block") do
    n.times do
      sometimes_block(true) { a += 1 }
    end
  end
  x.report("Proc.new") do
    n.times do
      sometimes_proc_new(true) { b += 1 }
    end
  end
  x.report("yield") do
    n.times do
      sometimes_yield(true) { c += 1 }
    end
  end
end

パフォーマンスはRuby 2.0.0p247と1.9.3p392の間で同様でした。1.9.3の結果は次のとおりです。

                  user     system      total        real
no &block     0.580000   0.030000   0.610000 (  0.609523)
no Proc.new   0.080000   0.000000   0.080000 (  0.076817)
no yield      0.070000   0.000000   0.070000 (  0.077191)
&block        0.660000   0.030000   0.690000 (  0.689446)
Proc.new      0.820000   0.030000   0.850000 (  0.849887)
yield         0.250000   0.000000   0.250000 (  0.249116)

常に使用されるわけではないときに明示的な&blockパラメータを追加すると、実際にメソッドの速度が低下します。ブロックがオプションの場合は、メソッドシグネチャに追加しないでください。また、ブロックを渡すために、yieldを別のブロックにラップするのが最も高速です。

ただし、これらは100万回の反復の結果であるため、あまり心配する必要はありません。 1つのメソッドが100万分の1秒のコストでコードを明確にする場合は、とにかくそれを使用します。

6
cbrauchli

ブロックを渡すのを忘れると、異なるエラーメッセージが表示されます。

> WithYield::thrice
LocalJumpError: no block given
        from (irb):3:in `thrice'
        from (irb):3:in `times'
        from (irb):3:in `thrice'

> WithProcCall::thrice
NoMethodError: undefined method `call' for nil:NilClass
        from (irb):9:in `thrice'
        from (irb):9:in `times'
        from (irb):9:in `thrice'

しかし、「通常の」（非ブロック）引数を渡そうとしても、同じように動作します。

> WithYield::thrice(42)
ArgumentError: wrong number of arguments (1 for 0)
        from (irb):19:in `thrice'

> WithProcCall::thrice(42)
ArgumentError: wrong number of arguments (1 for 0)
        from (irb):20:in `thrice'
6
Sam Stokes

Rubyでブロックを構築するかどうかを強制するかどうかによって、結果が異なることがわかりました（既存のprocなど）。

_require 'benchmark/ips'

puts "Ruby #{Ruby_VERSION} at #{Time.now}"
puts

firstname = 'soundarapandian'
middlename = 'rathinasamy'
lastname = 'arumugam'

def do_call(&block)
    block.call
end

def do_yield(&block)
    yield
end

def do_yield_without_block
    yield
end

existing_block = proc{}

Benchmark.ips do |x|
    x.report("block.call") do |i|
        buffer = String.new

        while (i -= 1) > 0
            do_call(&existing_block)
        end
    end

    x.report("yield with block") do |i|
        buffer = String.new

        while (i -= 1) > 0
            do_yield(&existing_block)
        end
    end

    x.report("yield") do |i|
        buffer = String.new

        while (i -= 1) > 0
            do_yield_without_block(&existing_block)
        end
    end

    x.compare!
end
_

結果を与える：

_Ruby 2.3.1 at 2016-11-15 23:55:38 +1300

Warming up --------------------------------------
          block.call   266.502k i/100ms
    yield with block   269.487k i/100ms
               yield   262.597k i/100ms
Calculating -------------------------------------
          block.call      8.271M (± 5.4%) i/s -     41.308M in   5.009898s
    yield with block     11.754M (± 4.8%) i/s -     58.748M in   5.011017s
               yield     16.206M (± 5.6%) i/s -     80.880M in   5.008679s

Comparison:
               yield: 16206091.2 i/s
    yield with block: 11753521.0 i/s - 1.38x  slower
          block.call:  8271283.9 i/s - 1.96x  slower
_

do_call(&existing_block)を_do_call{}_に変更すると、どちらの場合も約5倍遅くなります。この理由は明らかだと思います（Rubyは呼び出しごとにProcを構築することを強制されるため）。

2
ioquatix

ところで、これを現在の日に更新するには、次を使用します。

Ruby 1.9.2p180 (2011-02-18 revision 30909) [x86_64-linux]

Intel i7（1.5年前）。

user     system      total        real
0.010000   0.000000   0.010000 (  0.015555)
0.030000   0.000000   0.030000 (  0.024416)
0.120000   0.000000   0.120000 (  0.121450)
0.240000   0.000000   0.240000 (  0.239760)

それでも2倍遅い。面白い。

0
Travis Reeder