Question

我已经开始学习Ruby了，我已经阅读了几本教程，我甚至买了一本书（“编程Ruby 1.9 - 实用程序员指南”），我遇到了一些我以前从未见过的新东西。我知道的任何其他语言（我作为PHP web开发人员工作）。

阻止＆amp;特效。我想我明白它们是什么，但我不明白为什么它们如此伟大，何时以及为什么我应该使用它们。无论我到哪里，他们都说块和proc是Ruby中的一个很棒的功能，但是我不理解它们。

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

Answer 1

有很多关于积木的事情。电梯间距：阻止让我们传递动作，就像我们通常传递数据一样。

最明显的是，他们会让你把事情抽象成一些其他方式无法实现的功能。例如，让我们看一个常见的情况，你有一个事物列表，你想过滤它只包括符合某些标准的项目：

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给我们的东西。该块允许我们将自定义逻辑传递给此标准方法。

但是迭代器并不是"hole in the middle pattern"有用的唯一地方。例如，如果将块传递给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

Yowza。使用块，我们可以这样做（基于许多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块和两个{} - 样式块。但它很自然地读取，不是吗？这是有效的，因为块会捕获它创建的上下文，因此我们不需要传递self和item。

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

Answer 2

块在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');

Answer 3

重要的是查看块而不是使用方法来开始代码块，实际上您正在使用块并将其用作函数中的参数。

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

superOverFlowArray.each { |flow| puts flow }

您正在发送块{| flow |将flow}放入每个方法中。代码告诉ruby将数组的当前值发送到此块而不是| flow |。

Procs取一个块并将它们变成一个变量。 Proc是保存块的对象实例。块作为参数传递给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将记住传入的原始类别，允许以方便的方式对类型进行分组。

Answer 4

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

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

现在要利用这段代码，只需调用方法＆＃34; call＆＃34;你好。请注意，上面的示例接收代码块使用的参数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)

请注意＆符号＆＃34;＆amp;＆＃34;在hello允许你传递proc对象作为参数之前。

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

    some_class.output_value(1, 3)

您得到的结果如下：

    i am a proc
    sum: 4

请参阅!!就这么简单。你已经能够传递一大堆代码了。过程非常有用，以至于ruby大量使用它。希望这是非常有用的：）

Answer 5

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

Answer 6

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

即使map本身也非常强大，jQuery就是围绕这个概念构建的：

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

如果需要，你可以抛出逻辑

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

有一个聪明的运营商'＆amp;'这意味着“将符号转换为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

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

街区＆amp; Ruby中的过程

6 个答案: