81

该方法在 Ruby 中的以下两种实现之间的行为差​​异是什么thrice？

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

“行为差异”包括错误处理、性能、工具支持等。

4

5 回答 5

54

我认为第一个实际上是另一个的语法糖。换句话说，没有行为差异。

第二种形式允许的是将块“保存”在变量中。然后可以在其他某个时间点调用该块 - 回调。

好的。这次我去做了一个快速的基准测试：

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 倍。

于 2009-09-11T10:31:21.217 回答
8

其他答案非常彻底，Ruby 中的闭包广泛涵盖了功能差异。我很好奇哪种方法最适合可以选择接受块的方法，所以我写了一些基准测试（离开这个 Paul Mucur 帖子）。我比较了三种方法：

  • &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在另一个块中是最快的。

也就是说，这些是一百万次迭代的结果，所以不要太担心。如果一种方法以百万分之一秒为代价使您的代码更清晰，那么无论如何都要使用它。

于 2013-09-20T00:14:44.643 回答
7

如果您忘记传递一个块，它们会给出不同的错误消息：

> 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'
于 2009-09-11T10:31:35.800 回答
2

我发现结果会有所不同，具体取决于您是否强制 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）。

于 2016-11-15T10:58:23.080 回答
0

顺便说一句，只是为了将其更新到当前日期，使用：

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 倍。有趣的。

于 2011-05-04T04:51:36.013 回答