ruby-on-rails - validates - ruby on rails入门




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

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]

在Ruby on Rails书中看到这段代码。 第一个是视图,第二个是辅助模块。 我不明白那个&blockattributes={}怎么回事。 任何人都可以指导我一个解释这个的教程吗?

<% 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

Re attributes = {} ,这只是一个带有默认值的方法参数。 因此,如果您调用hidden_div_if(whatever) ,即仅传递第一个参数,则attributes将默认为空哈希。

这很有用,因为它稍后简化了设置attributes["style"] ,因为attributes不必首先初始化为哈希。 (尽管如此,这可能只是作为(attributes ||= {})["style"] = …

&block只是稍微复杂一点。

Ruby方法可以使用特殊语法method(args) { |block_args| block_code }来获取作为块的最后一个参数 method(args) { |block_args| block_code }&block基本上将block作为Proc对象捕获到block变量中。 所以block只是一个指向匿名过程的变量。

当稍后调用content_tag ,并且&block作为其最后一个参数传递时,它会扩展为一个块,就好像调用确实是content_tag(…) { block originally passed to hidden_if_div }

所以也许我真的很困惑。 你应该google的是“ruby默认参数”和“ruby blocks”。


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

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

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

robertsosinski.com/2008/12/21/…可以找到一些好的阅读以及对块,过程和lamdas的解释。


块是ruby的一个相当基本的部分。 它们由do |arg0,arg1| ... end分隔 do |arg0,arg1| ... end{ |arg0,arg1,arg2| ... } { |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:[email protected](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"

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

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

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





ruby