Ruby中的这个和块是什么？它是如何通过这里的方法传递的？

Question

在Ruby on Rails书中看到这段代码.第一个是视图,第二个是辅助模块.我不明白怎么&block和attributes={}东西的工作.任何人都可以指导我一个解释这个的教程吗？

<% hidden_div_if(@cart.items.empty?, :id => "cart") do %>
 <%= render(:partial => "cart", :object => @cart) %>
<% end %>

module StoreHelper
 def hidden_div_if(condition, attributes = {}, &block)
  if condition
   attributes["style"] = "display: none"
  end
   content_tag("div", attributes, &block)
  end
end

Answer 1

块是ruby的一个相当基本的部分.他们被任何一个do |arg0,arg1| ... end或两个分隔{ |arg0,arg1,arg2| ... }.

它们允许您指定要传递给方法的回调.可以通过两种方式调用此回调 - 通过指定前缀的最终参数捕获它&,或者使用yield关键字:

irb> def meth_captures(arg, &block)
       block.call( arg, 0 ) + block.call( arg.reverse , 1 )
     end
#=> nil
irb> meth_captures('pony') do |word, num|
       puts "in callback! word = #{word.inspect}, num = #{num.inspect}"
       word + num.to_s
     end
in callback! word = "pony" num = 0
in callback! word = "ynop" num = 1
#=> "pony0ynop1" 
irb> def meth_yields(arg)
       yield(arg, 0) + yield(arg.upcase, 1)
     end
#=> nil
irb> meth_yields('frog') do |word, num|
       puts "in callback! word = #{word.inspect}, num = #{num.inspect}"
       word + num.to_s
     end
in callback! word = "frog", num = 0
in callback! word = "FROG", num = 1
#=> "frog0FROG1"

请注意,我们的回调在每种情况下都是相同的 - 我们可以通过在对象中保存回调来删除重复,然后将其传递给每个方法.这可以使用lambda捕获对象中的回调来完成,然后通过为其添加前缀来传递给方法&.

irb> callback = lambda do |word, num|
       puts "in callback! word = #{word.inspect}, num = #{num.inspect}"
       word + num.to_s
     end
#=> #<Proc:0x0052e3d8@(irb):22>
irb> meth_captures('unicorn', &callback)
in callback! word = "unicorn", num = 0
in callback! word = "nrocinu", num = 1
#=> "unicorn0nrocinu1"
irb> meth_yields('plate', &callback)
in callback! word = "plate", num = 0
in callback! word = "PLATE", num = 1
#=> "plate0PLATE1"

理解&这里作为函数最后一个参数的前缀的不同用法很重要

• 在函数定义中,它将任何传递的块捕获到该对象中
• 在函数调用中,它将给定的回调对象扩展为一个块

如果你环顾四周,那么整个地方都会使用块,特别是在迭代器中Array#each.

Answer 2

Blocks,Procs和lambdas(在计算机科学中称为闭包)是Ruby最强大的方面之一,也是最容易被误解的方面之一.这可能是因为Ruby以一种相当独特的方式处理闭包.让事情变得更复杂的是Ruby有四种不同的使用闭包的方式,每种闭包都有点不同,有时候是荒谬的.有很多站点提供了一些关于闭包在Ruby中如何工作的非常好的信息.但我还没有找到一个好的,权威的指南.

class Array
  def iterate!(&code)
    self.each_with_index do |n, i|
      self[i] = code.call(n)
    end
  end
end

array = [1, 2, 3, 4]

array.iterate! do |n|
  n ** 2
end

程序,AKA,Procs

块非常方便且语法简单,但是我们可能希望拥有许多不同的块,并且可以多次使用它们.因此,一次又一次地通过同一个街区将要求我们重复自己.但是,由于Ruby完全面向对象,因此可以将可重用代码保存为对象本身,从而可以非常干净地处理.这个可重用的代码称为Proc(过程的简称).块和Procs之间的唯一区别是块是无法保存的Proc,因此是一次性使用的解决方案.通过与Procs合作,我们可以开始执行以下操作:

class Array
  def iterate!(code)
    self.each_with_index do |n, i|
      self[i] = code.call(n)
    end
  end
end

array_1 = [1, 2, 3, 4]
array_2 = [2, 3, 4, 5]

square = Proc.new do |n|
  n ** 2
end

Lambda表达式

到目前为止,您已经以两种方式使用了Procs,将它们作为属性直接传递并将它们保存为变量.这些过程与其他语言称为匿名函数或lambdas的行为非常相似.为了让事情更有趣,lambdas也可以在Ruby中使用.看一看:

class Array
  def iterate!(code)
    self.each_with_index do |n, i|
      self[i] = code.call(n)
    end
  end
end

array = [1, 2, 3, 4]

array.iterate!(lambda { |n| n ** 2 })

puts array.inspect

块

在Ruby中使用闭包的最常见,最简单和最可靠的"Ruby like"方式是使用块.他们有以下熟悉的语法:

array = [1, 2, 3, 4]

array.collect! do |n|
  n ** 2
end

puts array.inspect

# => [1, 4, 9, 16]

Answer 3

这&block是一种将一段Ruby代码发送到方法然后在该方法范围内评估该代码的方法.在上面的示例代码中,它表示将在div中呈现部分命名的购物车.我认为术语闭包用于计算机科学.

所以在你的例子中&block是:

<%= render(:partial => "cart", :object => @cart) %>

在Robert Sosinski的博客中可以找到一些好的阅读以及对块,过程和lamdas的解释.