ruby - Ruby 中的块和过程

Question

我已经开始学习 Ruby，并且阅读了一些教程，甚至还买了一本书（“Programming Ruby 1.9 - The Pragmatic Programmers' Guide”），我发现了一些我以前从未见过的新东西我知道的其他语言（我是一名 PHP 网络开发人员）。

块和过程。我想我了解它们是什么，但我不明白为什么它们如此出色，以及我应该在何时以及为什么使用它们。我到处看他们都说块和过程是 Ruby 中的一个很棒的特性，但我不理解它们。

这里的任何人都可以给像我这样的Ruby新手一些解释吗？

score 14 · Accepted Answer

积木有很多好处。电梯间距：块让我们像通常传递数据一样传递动作。

最明显的层次是它们让您可以将事物抽象为其他方式无法实现的功能。例如，让我们看一个常见的情况，您有一个事物列表，并且您希望过滤它以仅包含符合某些条件的项目：

int list[50] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50};
int evenNumbers[50] = {0};
int copyIndex = 0;
for (int i = 0; i < 50; i++) {
    if (list[i] % 2 == 0) {
        evenNumbers[copyIndex++] = list[i];
    }
}

以下是您在 Ruby 中的编写方式：

list = 1..50
listCopy = list.select {|n| n.even?}

所有常见的忙碌工作都从您的代码中移出，并移入具有有意义名称的方法中。我们不关心复制数组和遍历索引等等——我们只需要一个过滤列表。这就是select给我们的。该块允许我们将自定义逻辑传递到此标准方法中。

但是迭代器并不是这个“中间模式中的洞”有用的唯一地方。例如，如果您将一个块传递给File.open，它将打开文件，使用该文件执行该块，然后为您关闭该文件。

块给我们的另一件事是一种非常强大的回调形式。例如，如果没有块，我们可能不得不做这样的事情（基于对话框在 Objective-C Cocoa 中的实际工作方式）：

class Controller
  def delete_button_clicked(item)
    item.add_red_highlight
    context = {:item => item}
    dialog = Dialog.new("Are you sure you want to delete #{item}?")
    dialog.ok_callback = :delete_OK
    dialog.ok_receiver = self
    dialog.cancel_callback = :cancel_delete
    dialog.cancel_receiver = self
    dialog.context = context
    dialog.ask_for_confirmation
  end

  def delete_OK(sender)
    delete(sender.context[:item])
    sender.dismiss
  end

  def cancel_delete(sender)
    sender.context[:item].remove_red_highlight
    sender.dismiss
  end
end

约扎。使用块，我们可以这样做（基于许多 Ruby 库中使用的通用模式）：

class Controller
  def delete_button_clicked(item)
    item.add_red_highlight
    Dialog.ask_for_confirmation("Are you sure you want to delete #{item}?") do |response|
      response.ok { delete item }
      response.cancel { item.remove_red_highlight }
    end
  end
end

这实际上是两个级别的块——do...end块和两种{}样式的块。但它读起来很自然，不是吗？这是有效的，因为一个块捕获了它创建的上下文，所以我们不需要传递selfand item。

至于 Procs，它们只是块的对象包装器。对他们来说不是很多。

score 2 · Accepted Answer

块在 Ruby 类中的许多方法中使用，并且在 PHP 中使用回调的地方使用它们。

[1,2,3,4,5].each {|i| print "#{i} "}

[1,2,3,4,5].each do |i|
  print "#{i} "
end

File.open('p014constructs.rb', 'r') do |f1|  
  while line = f1.gets  
    puts line
  end
end

PHP5 引入了匿名函数；您可以使用匿名函数，而不是使用回调。

echo preg_replace_callback('~-([a-z])~', function ($match) {
  return strtoupper($match[1]);
}, 'hello-world');

score 2 · Accepted Answer

重要的是不要将块视为使用方法来开始代码块，您实际上是在获取块并像函数中的参数一样使用它。

因此，当您使用 each 方法迭代数组时，如下所示：

superOverFlowArray.each { |flow| puts flow }

您正在发送块 { |flow| 将 flow } 放入 each 方法中。代码告诉 ruby 将数组的当前值发送到这个块来代替 |flow|。

Procs 接受一个块并将它们变成一个变量。Procs 是保存块的对象实例。块作为参数传递给 proc，并在您在该 Proc 实例上调用“call”方法时执行。

所以这是一个 Proc 示例：

def category_and_title(category)
     Proc.new { |title| "The title is: " + title + " in category: " + category }
end

myFirstTitle = category_and_title("Police Drama")
mySecondTitle = category_and_title("Comedy")

puts myFirstTitle.call("Law and Order")
puts mySecondTitle.call("Seinfeld")
puts myFirstTitle.call("CSI")

Proc 将记住传入的原始类别，从而可以方便地对类型进行分组。

score 1 · Accepted Answer

Procs，也称为闭包或 lambdas 是 ruby 中的一个概念，起初可能看起来令人困惑，尤其是对于新手而言。简而言之，procs 允许您轻松地传递代码块。一个例子，下面

    hello = Proc.new do |x, y|
      puts "i am a proc"
      sum = x+y
      puts "sum: #{sum}"
    end

现在要使用这段代码，只需在 hello 上调用方法“call”。请注意，上面的示例接收代码块使用的参数 x 和 y。因此，当您像我在下面所做的那样调用 Proc 对象时，请务必传递参数：

    hello.call(2, 3)

产生以下结果：

    i am a proc
    sum: 5

欢呼！！这是创建 Proc 对象的简单方法。这有多大用处？好吧，proc 对象允许您传递代码块。下面的插图通过使用上面示例中创建的 proc 更好地解释了它。让我们创建一些随机类，

    class SomeClass
      def initialize(&block)
        @block = block
      end

      def output_value(x, y)
        @block.call(x, y)
      end
    end

现在，让我们创建一个 SomeClass 的实例，

    some_class = SomeClass.new(&hello)

请注意，在 hello 之前的 & 符号“&”允许您将 proc 对象作为参数传递。

最后，让我们通过传递 2 个参数来输出一个值，如下所示：

    some_class.output_value(1, 3)

你得到的结果如下：

    i am a proc
    sum: 4

看！！就这么简单。您已经能够传递大量代码。Procs 非常有用，以至于 ruby 大量使用它。希望这非常有帮助:)

score 0 · Accepted Answer

这些概念与从函数式编程到 ruby 的概念相关联，因此它使您能够使用通常在语言中发现的模式和技术，其中函数是一等公民。

score 0 · Accepted Answer

块和过程让您可以提取少量代码，而无需方法的全部开销和复杂性。

即使map它本身也非常强大，并且 jQuery 也是围绕同样的概念构建的：

  ['spite','rest','purpose'].map {|s| s << 'ful' }

如有必要，您可以输入逻辑

  ['sprite','restful','luck'].map {|s| s << (s.end_with?('uck') ? 'i' : '') << 'ly' }

有一个聪明的运算符 '&' 表示“将符号转换为 proc 并调用它”，因此您可以转换对象字符串：

  ['spite',12,:purpose].map(&:to_s)

使用闭包并结合编写一个简单的闭包，我们可以找到相邻数字出现的位置。这是相当笨拙的 Ruby，但比大多数语言更简洁：

  last = -2 # this variable is accessed and changed within the closure
  objs.sort.map do |o|
    if (last + 1) != o
       last = o
       nil # not one more than previous so return nil
    else
       o
    end
  end.compact  # compact removes nils

当您开始用另一种语言重写它时，您会意识到这是多么方便。它鼓励您将代码构造成更小的操作，因此它更易于重用和可测试。

ruby - Ruby 中的块和过程

6 回答 6

Related

Reference