Ruby 块的最佳解释？

Question

Closed. This question is opinion-based. It is not currently accepting answers.

---

想要改进这个问题？更新问题，以便可以通过编辑这篇文章用事实和引文来回答它。

11 年前已关闭。

Answer 1

我提供了我自己的解释 这个答案，稍作修改：

Ruby 中的“块”与一般编程术语“代码块”或“代码块”不同。

假设以下（无效）Ruby 代码确实有效：

def add10( n )
  puts "#{n} + 10 = #{n+10}"
end

def do_something_with_digits( method )
  1.upto(9) do |i|
    method(i)
  end
end

do_something_with_digits( add10 )
#=> "1 + 10 = 11"
#=> "2 + 10 = 12"
...
#=> "9 + 10 = 19"

虽然该代码无效，但其意图（将一些代码传递给方法并让该方法运行该代码）在 Ruby 中可以通过多种方式实现。其中一种方法是“块”。

Ruby 中的块非常非常像方法：它可以接受一些参数并为这些参数运行代码。每当你看到 foo{ |x,y,z| ... } 或 foo do |x,y,z| ... end，这些块采用三个参数并对它们运行 ...。 （您甚至可能会看到上面的 upto 方法正在传递一个块。）

因为块是 Ruby 语法的特殊部分，所以允许每个方法传递一个堵塞。方法是否使用块取决于方法。例如：

def say_hi( name )
  puts "Hi, #{name}!"
end

say_hi("Mom") do
  puts "YOU SUCK!"
end
#=> Hi, Mom!

上面的方法传递了一个准备发出侮辱的块，但由于该方法从不调用该块，因此只打印好消息。下面是我们如何从方法中调用块：

def say_hi( name )
  puts "Hi, #{name}!"
  if block_given?
    yield( name )
  end
end

say_hi("Mridang") do |str|
  puts "Your name has #{str.length} letters."
end
#=> Hi, Mridang!
#=> Your name has 7 letters.

我们使用 block_given? 来查看块是否被传递。在本例中，我们将一个参数传递回块；由您的方法来决定将什么传递给块。例如：

def say_hi( name )
  puts "Hi, #{name}!"
  yield( name, name.reverse ) if block_given?
end

say_hi("Mridang"){ |str1, str2| puts "Is your name #{str1} or #{str2}?" }
#=> Hi, Mridang!
#=> Is your name Mridang or gnadirM?

这只是某些类将刚刚创建的实例传递给块的一种约定（也是一个很好的约定，也是您想要支持的约定）。

这不是一个详尽的答案，因为它没有涵盖捕获块作为参数、它们如何处理数量、块参数中的不扩散等，但旨在作为 Blocks-Are-Lambdas 介绍。 >

Answer 2

Ruby 块是创建 Proc 对象 代表可以被其他代码使用的代码。 Proc 对象是大括号 {} 之间的指令（或多行块的 do...end 短语，其优先级低于大括号），可以选择接受参数并返回值（例如 {|x,y| x+y}）。 Proc 是第一类对象，可以显式构造或作为方法伪隐式获得参数：

1. 构造为 Proc 对象（或使用lambda 关键字）：

   add1 = Proc.new {|x| x+1} # 返回其参数加一。
   add1.call(1) # =>; 2
   

2. 作为方法伪参数传递，显式使用特殊的 & 最后参数语法糖运算符或隐式使用 block_given?/产量对：

   def times_do(&proc) # “proc”是调用此方法的块。
     2.times { proc.call() } 如果 proc
   结尾
   times_do { puts "OK" } # 在不同的行上打印两次“OK”。
   
   def thrice_do() # 如果给出了一个块，则可以使用“yield”调用它。
     3.times { 产量 } if block_given?
   结尾
   thrice_do { put "OK" } # 在单独的行上打印三次“OK”。
   

第二种形式通常用于访问者模式；数据可以作为 call 或 yield 方法的参数传递给特殊块参数。

Answer 3

来自Why（令人心酸的）Ruby 指南：

任何用大括号括起来的代码都是
一个区块。

2.times { print "是的，我用过
在我的例子中是厚块培根，但从来没有
再次！” } 就是一个例子。

使用块，您可以将一组
一起指示，以便他们能够
被传递到你的程序中。这
大括号看起来像
螃蟹钳子已经抢走了
代码并将其结合在一起。什么时候
你看到这两个钳子，记住
里面的代码已经被按下了
成一个单元。这就像其中之一
那些小凯蒂猫盒子
在塞满了东西的商场里卖
小铅笔和微型纸，
全部挤进闪闪发光的
可隐藏的透明外壳
在您的手掌中进行隐蔽固定
运营。除了块没有
需要那么多的眯眼。卷发的
牙套也可以交易
词 do 和 end，如果
你的块比一行长。

loop do
  print "Much better."    
  print "Ah. More space!"
  print "My back was killin' me in those crab pincers."
end

块参数是
由管道包围的变量集
字符并用逗号分隔。

|x|, |x,y|, and |up, down, all_around| are examples.

使用块参数
在块的开头。

{ |x,y| x + y }

在上面的例子中，|x,y|是论据。争论过后，我们
有一点代码。表达式 x +
y 将两个参数相加。我
喜欢思考管道字符
代表一条隧道。他们给
滑道的外观
变量正在下滑。 （一个 x 出现
鹰向下展开，而它们整齐地
交叉双腿。）这个滑道的作用是
街区和街区之间的通道
他们周围的世界。变量是
通过这个滑道（或隧道）
进入区块。

Answer 4

对于具有 C# 背景（或其他语言）背景的任何人来说，这可能会有所帮助：

Ruby 块就像 C# 中的 lambda 表达式和匿名方法。它们就是 C# 所说的委托（Ruby 称之为 Procs），也就是说它们本质上是可以作为值传递的函数。在 Ruby 和 C# 中，它们也可以表现为闭包。

红宝石： <代码>{ |x| x + 1 }

C#: x => x + 1

Ruby: { |name|放置“你好#{name}”}

C#：name => { Console.WriteLine("你好 {0}", name); 。

C# 和 Ruby 都提供了编写上述示例的替代方法

Ruby：

do |name|
   puts "Hello there #{name}"
end

C#：

delegate(string name)
{
   Console.WriteLine("Hello there {0}", name);
}

在 Ruby 和 C# 中，都允许使用多个语句。在 Ruby 中，需要使用上面的第二种语法。

这些概念在许多其他受到函数式编程背后的思想影响的语言中也可用。

Answer 5

《Programming Ruby》一书有很棒的块的说明以及使用它们。

在 1.9+ 中，传递到块中的参数列表变得更加复杂，允许定义局部变量：

do |a,b;c,d| 
  some_stuff
end

;c,d 在块内声明两个新的局部变量，它们不接收来自被调用的值-routine 的 yield 语句。 Ruby 1.9+ 保证，如果变量存在于块之外，则它们不会被块内的同名变量所影响。这是新的行为； 1.8会踩在他们身上。

def blah
  yield 1,2,3,4
end

c = 'foo'
d = 'bar'

blah { |a, *b; c,d|
  c = 'hello'
  d = 'world'
  puts "a: #{a}", "b: #{b.join(',')}", "c: #{c}", "d: #{d}" 
}

puts c, d
# >> a: 1
# >> b: 2,3,4
# >> c: hello
# >> d: world
# >> foo
# >> bar

还有“splat”运算符 *，它在参数列表中工作：

do |a,*b| 
  some_stuff
end

将多个值中的第一个分配给“a”，其余所有值将在“b”中捕获，这将是像数组一样处理。 * 可以位于 a 变量上：

do |*a,b| 
  some_stuff
end

将捕获除最后一个变量之外的所有传入变量，该变量将传递给 b。并且，与前两个类似：

do |a,*b,c| 
  some_stuff
end

将第一个值分配给 a，将最后一个值分配给 c，并将所有/任何中间值分配给 b 。

我认为这非常强大且流畅。

例如：

def blah
  yield 1,2,3,4
end

blah { |a, *b| puts "a: #{a}", "b: #{b.join(',')}" }
# >> a: 1
# >> b: 2,3,4

blah { |*a, b| puts "a: #{a.join(',')}", "b: #{b}" }
# >> a: 1,2,3
# >> b: 4

blah { |a, *b, c| puts "a: #{a}", "b: #{b.join(',')}", "c: #{c}" }
# >> a: 1
# >> b: 2,3
# >> c: 4

Answer 6

块是匿名一等过程的轻量级文字，具有一些恼人的限制。它们在 Ruby 中的工作方式与在几乎所有其他编程语言中的工作方式相同，模数上述限制，即：

• 块只能出现在参数列表中
• 最多一个块可以出现在参数列表中（并且它必须是最后一个参数）

Answer 7

块是 Ruby 中对代码进行分组的一种方式。有两种写块的方法。一种是使用 do..end 语句，另一种是将代码括在大括号中：{}。块在 Ruby 编程语言中被视为对象，默认情况下所有函数都接受隐式块参数。

以下是执行相同操作的块的两个示例：

2.times { puts 'hi' }
2.times do
  puts 'hi'
end

块可以接收竖线 || 内以逗号分隔的参数列表。例如：

[1,2].map{ |n| n+2 } # [3, 4]

块（在 ruby​​ 1.9.2 中）可以显式拥有局部变量：

x = 'hello'
2.times do |;x|
  x = 'world'
  puts x
end

=> world
=> world

局部变量可以与参数组合：

[1,2].map{ |n;x| n+2 }

所有函数都可以接收默认块参数：

def twice
  yield
  yield
end

twice { puts 'hello' }
=> hello
=> hello

do..end 和 {} 块之间有什么区别？按照约定，{} 块位于单行上，而 do..end 块跨越多行，因为这样更容易阅读。主要区别与优先级有关：

array = [1,2]

puts array.map{ |n| n*10 } # puts (array.map{ |n| n*10 })
=> 10
=> 20

puts array.map do |n| n*10 end # (puts array.map) do |n| n*10 end
=> <Enumerator:0x00000100862670>