Ruby 中的块和收益

Question

我试图了解块和产量以及它们在 Ruby 中的工作原理。

如何使用yield？我研究过的许多 Rails 应用程序都以一种奇怪的方式使用 yield。

有人可以向我解释或告诉我去哪里理解它们吗？

Answer 1

是的，一开始有点令人困惑。

在 Ruby 中，方法可以接收代码块以执行任意代码段。

当方法需要块时，您可以通过调用 yield 函数来调用它。

示例：

以 Person 为例，它是一个具有 name 属性和 do_with_name 方法的类。当调用该方法时，它将把 name 属性传递给块。

class Person 
    def initialize( name ) 
         @name = name
    end

    def do_with_name   # expects a block
        yield( @name ) # invoke the block and pass the `@name` attribute
    end
end

现在您可以调用此方法并传递任意代码块。

person = Person.new("Oscar")

# Invoking the method passing a block to print the value
person.do_with_name do |value|
    puts "Got: #{value}"
end

将打印：

Got: Oscar

请注意，该块接收一个名为 value 的变量作为参数。当代码调用 yield 时，它会将 @name 的值作为参数传递。

yield( @name )

可以使用不同的块调用相同的方法。

例如反转名称：

reversed_name = ""

# Invoke the method passing a different block
person.do_with_name do |value| 
    reversed_name = value.reverse
end

puts reversed_name

=> "racsO"

其他更有趣的现实生活示例：

过滤数组中的元素：

 days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]  

 # Select those which start with 'T' 
 days.select do | item |
     item.match /^T/
 end

=> ["Tuesday", "Thursday"]

或按名称长度排序：

 days.sort do |x,y|
    x.size <=> y.size
 end

=> ["Monday", "Friday", "Tuesday", "Thursday", "Wednesday"]

如果块是可选的，则可以使用：

yield(value) if block_given?

如果不是可选的，则只需调用它。

您可以使用 irb 在计算机上尝试这些示例（交互式 Ruby Shell ）

以下是复制/粘贴就绪形式的所有示例：

class Person 
    def initialize( name ) 
         @name = name
    end

    def do_with_name   # expects a block
        yield( @name ) # invoke the block and pass the `@name` attribute
    end
end


person = Person.new("Oscar")

# Invoking the method passing a block to print the value
person.do_with_name do |value|
    puts "Got: #{value}"
end


reversed_name = ""

# Invoke the method passing a different block
person.do_with_name do |value| 
    reversed_name = value.reverse
end

puts reversed_name



# Filter elements in an array:    
days = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]  

# Select those which start with 'T' 
days.select do | item |
    item.match /^T/
end



# Sort by name length:     
days.sort do |x,y|
   x.size <=> y.size
end

Answer 2

在 Ruby 中，方法可以检查它们的调用方式是否除了正常参数之外还提供了块。通常，这是使用 block_given? 方法完成的，但您也可以通过在最终参数名称之前添加前缀 & 符号 (&) 来将该块引用为显式 Proc。

如果使用块调用方法，则如果需要，该方法可以使用一些参数将控制权交给块（调用块）。考虑这个示例方法，它演示了：

def foo(x)
  puts "OK: called as foo(#{x.inspect})"
  yield("A gift from foo!") if block_given?
end

foo(10)
# OK: called as foo(10)
foo(123) {|y| puts "BLOCK: #{y} How nice =)"}
# OK: called as foo(123)
# BLOCK: A gift from foo! How nice =)

或者，使用特殊的块参数语法：

def bar(x, &block)
  puts "OK: called as bar(#{x.inspect})"
  block.call("A gift from bar!") if block
end

bar(10)
# OK: called as bar(10)
bar(123) {|y| puts "BLOCK: #{y} How nice =)"}
# OK: called as bar(123)
# BLOCK: A gift from bar! How nice =)

Answer 3

很可能有人会在这里提供真正详细的答案，但我总是发现 这篇来自 Robert Sosinski 的文章 很好地解释了块、过程和表达式之间的微妙之处。拉姆达。

我应该补充一点，我相信我链接的帖子是特定于 ruby​​ 1.8 的。 ruby 1.9 中发生了一些变化，例如块变量是块的本地变量。在 1.8 中，您会得到类似以下内容的信息：

>> a = "Hello"
=> "Hello"
>> 1.times { |a| a = "Goodbye" }
=> 1
>> a
=> "Goodbye"

而 1.9 则会显示：

>> a = "Hello"
=> "Hello"
>> 1.times { |a| a = "Goodbye" }
=> 1
>> a
=> "Hello"

我这台机器上没有 1.9，因此上面的内容可能有错误。

Answer 4

我发现这篇文章非常有用。特别是下面的示例：

#!/usr/bin/ruby

def test
  yield 5
  puts "You are in the method test"
  yield 100
end

test {|i| puts "You are in the block #{i}"}

test do |i|
    puts "You are in the block #{i}"
end

应该给出以下输出：

You are in the block 5
You are in the method test
You are in the block 100
You are in the block 5
You are in the method test
You are in the block 100

因此，每次调用 yield 时，ruby 都会运行 do 块中或 do 块中的代码。代码>{}。如果为 yield 提供了参数，则该参数将作为参数提供给 do 块。

对我来说，这是我第一次真正理解 do 块的作用。它基本上是函数访问内部数据结构的一种方式，无论是迭代还是函数配置。

因此，在 Rails 中，您可以编写以下内容：

respond_to do |format|
  format.html { render template: "my/view", layout: 'my_layout' }
end

这将运行 respond_to 函数，该函数生成带有（内部）format 参数的 do 块。然后，您可以在此内部变量上调用 .html 函数，该函数又会生成用于运行 render 命令的代码块。请注意，.html 仅当它是所请求的文件格式时才会产生。 （技术性：这些函数实际上使用 block.call 而不是 yield，正如您从 source 但功能本质上是相同的，请参阅

或者换句话说，它类似于一个函数以匿名函数作为参数，然后在 javascript 中调用它。

Answer 5

我想在已经很好的答案中添加为什么你会这样做。

不知道你来自什么语言，但假设它是静态语言，这种事情看起来很熟悉。这就是你在java中读取文件的方式

public class FileInput {

  public static void main(String[] args) {

    File file = new File("C:\\MyFile.txt");
    FileInputStream fis = null;
    BufferedInputStream bis = null;
    DataInputStream dis = null;

    try {
      fis = new FileInputStream(file);

      // Here BufferedInputStream is added for fast reading.
      bis = new BufferedInputStream(fis);
      dis = new DataInputStream(bis);

      // dis.available() returns 0 if the file does not have more lines.
      while (dis.available() != 0) {

      // this statement reads the line from the file and print it to
        // the console.
        System.out.println(dis.readLine());
      }

      // dispose all the resources after using them.
      fis.close();
      bis.close();
      dis.close();

    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

忽略整个流链接的事情，这个想法是

1. 初始化需要清理的资源
2. 使用资源
3. 确保清理它

这与你在ruby中的做法

File.open("readfile.rb", "r") do |infile|
    while (line = infile.gets)
        puts "#{counter}: #{line}"
        counter = counter + 1
    end
end

截然不同。分解这一点，

1. 告诉 File 类如何初始化资源，
2. 告诉文件类如何处理它，
3. 嘲笑那些还在打字的 java 人;-)

在这里，您基本上不用处理第一步和第二步，而是将其委托给另一堂课。正如您所看到的，这极大地减少了您必须编写的代码量，从而使代码更易于阅读，并减少了内存泄漏或文件锁未清除等问题的可能性。

现在，并不是说你不能在 java 中做类似的事情，事实上，人们已经这样做了几十年了。它称为策略模式。不同之处在于，如果没有块，对于像文件示例这样的简单内容，由于需要编写的类和方法的数量，策略就变得矫枉过正。使用块，这是一种简单而优雅的方法，不以这种方式构建代码是没有任何意义的。

这不是使用块的唯一方式，但其他方式（例如 Builder 模式，您可以在 Rails 中的 form_for api 中看到）非常相似，一旦您了解了这一点，就会很明显发生了什么。当您看到块时，通常可以安全地假设该方法调用就是您想要执行的操作，并且该块正在描述您想要如何执行它。

Answer 6

在 Ruby 中，块基本上是可以传递给任何方法并由任何方法执行的代码块。块始终与方法一起使用，方法通常向块提供数据（作为参数）。

块广泛用于 Ruby gem（包括 Rails）和编写良好的 Ruby 代码中。它们不是对象，因此不能分配给变量。

基本语法

块是由 { } 或 do..end 括起来的一段代码。按照约定，大括号语法应用于单行块，而 do..end 语法应用于多行块。

{ # This is a single line block }

do
  # This is a multi-line block
end 

任何方法都可以接收块作为隐式参数。块由方法内的yield 语句执行。基本语法是：

def meditate
  print "Today we will practice zazen"
  yield # This indicates the method is expecting a block
end 

# We are passing a block as an argument to the meditate method
meditate { print " for 40 minutes." }

Output:
Today we will practice zazen for 40 minutes.

当到达yield语句时，meditate方法将控制权交给块，​​执行块内的代码并将控制权返回给方法，该方法在yield语句之后立即恢复执行。

当一个方法包含yield语句时，它期望在调用时接收一个块。如果未提供块，则一旦到达yield 语句就会抛出异常。我们可以使该块可选并避免引发异常：

def meditate
  puts "Today we will practice zazen."
  yield if block_given? 
end meditate

Output:
Today we will practice zazen. 

不可能将多个块传递给一个方法。每种方法只能接收一个块。

查看更多信息：http://www.zenruby.info /2016/04/introduction-to-blocks-in-ruby.html

Answer 7

我有时会这样使用“yield”：

def add_to_http
   "http://#{yield}"
end

puts add_to_http { "www.example.com" }
puts add_to_http { "www.victim.com"}

Answer 8

简单来说，Yields 允许您创建的方法接受和调用块。明确来说，yield 关键字是块中“内容”将被执行的位置。

Answer 9

关于yield，我想在这里提出两点。首先，虽然这里的很多答案都讨论了将块传递给使用yield的方法的不同方法，但我们也讨论一下控制流。这尤其重要，因为您可以多次生成一个块。我们来看一个例子：

class Fruit
  attr_accessor :kinds

  def initialize 
    @kinds = %w(orange apple pear banana)
  end

  def each 
    puts 'inside each'
    3.times { yield (@kinds.tap {|kinds| puts "selecting from #{kinds}"} ).sample }
  end  
end

f = Fruit.new
f.each do |kind|
  puts 'inside block'
end    

=> inside each
=> selecting from ["orange", "apple", "pear", "banana"]
=> inside block
=> selecting from ["orange", "apple", "pear", "banana"]
=> inside block
=> selecting from ["orange", "apple", "pear", "banana"]
=> inside block

当调用each方法时，它会逐行执行。现在，当我们到达 3.times 块时，该块将被调用 3 次。每次它调用yield。该yield 链接到与调用each 方法的方法关联的块。值得注意的是，每次调用yield 时，它都会将控制权返回给客户端代码中的each 方法的块。一旦该块执行完毕，它就会返回到 3.times 块。并且这种情况发生了 3 次。因此，客户端代码中的该块会在 3 个不同的场合被调用，因为 Yield 被显式调用了 3 次。

我的第二点是关于 enum_for 和 Yield。 enum_for 实例化 Enumerator 类，并且此 Enumerator 对象也响应yield。

class Fruit
  def initialize
    @kinds = %w(orange apple)
  end

  def kinds
    yield @kinds.shift
    yield @kinds.shift
  end
end

f = Fruit.new
enum = f.to_enum(:kinds)
enum.next
 => "orange" 
enum.next
 => "apple" 

因此请注意，每次我们使用外部迭代器调用种类时，它只会调用一次yield。下次我们调用它时，它将调用下一个yield，依此类推。

关于 enum_for 有一个有趣的花絮。在线文档声明如下：

enum_for(method = :each, *args) → enum
Creates a new Enumerator which will enumerate by calling method on obj, passing args if any.

str = "xyz"
enum = str.enum_for(:each_byte)
enum.each { |b| puts b }    
# => 120
# => 121
# => 122

如果您没有指定符号作为 enum_for 的参数，ruby 会将枚举器挂接到接收者的each 方法。有些类没有each 方法，例如String 类。

str = "I like fruit"
enum = str.to_enum
enum.next
=> NoMethodError: undefined method `each' for "I like fruit":String

因此，对于使用 enum_for 调用某些对象的情况，您必须明确您的枚举方法是什么。

Answer 10

Yield 可以用作无名块以在方法中返回值。考虑以下代码：

Def Up(anarg)
  yield(anarg)
end

您可以创建一个方法“Up”，并为其分配一个参数。您现在可以将此参数分配给yield，它将调用并执行关联的块。您可以在参数列表之后分配块。

Up("Here is a string"){|x| x.reverse!; puts(x)}

当Up方法调用yield时，带有一个参数，它被传递给块变量来处理请求。