kenlistian

. :: ,* 的细节使用

Super

语法:

super
super(表达式, ... )

用于类继承中，super调用的父类覆盖的同名方法。若省略括号和参数时，将会把当前方法的参数原封不动地传递给父类中的同名方法。若调用时不想使用参数的话，请使用括号显式地标出，像super()这样。

其实就是delphi中的inherited，在c中就是直接写父类和其方法名。

-----------------------------------------

带块的方法调用

例:

[1,2,3].each do |i| print i*2, "\n" end
[1,2,3].each {|i| print i*2, "\n" }

语法:

method(arg1, arg2, ...)  do [`|' 表达式 ... `|'] 表达式 ... end
method(arg1, arg2, ...) `{' [`|' 表达式 ... `|'] 表达式 ... `}'
method(arg1, arg2, ..., `&' proc_object)

将do...end或{...}中的代码片段(也就是块)添加在方法后面，然后再调用该方法时，就能从该方法
内部对快进行计算。在带块的方法内进行块调用时使用 yield 表达式。
传给yield的值会被赋值给夹在"｜｜"中的变量。

{...}比do...end块的结合能力强。例如：

foobar a, b do .. end   # foobar 是带块的方法
foobar a, b { .. }      # b    成了带块的方法

块中首次被赋值(声明)的局部变量的作用域仅限于该块。例如：

foobar {
  i = 20                # 声明了局部变量i
   ...
}
print defined? i        # 此处的i尚未定义，false
foobar a, b do
  i = 11                # 声明了一个新变量i
   ...
end

如下所示，在块外仍然有效。

i = 10
[1,2,3].each do |m|
  p i * m               # 马上就能使用i
end

采用&来调用过程对象，
嘿，像在一个函数参数是另一个函数地址作为参数传入一样。
还可以把过程对象( Proc )当作块传递给带块的方法。这时要在过程对象名前面添加"&"，
并把该过程对象传递给带块的方法的最后一个参数。除了过程对象以外，还可以传递方法对象( Method )。这时将生成一个调用该方法的过程对象，然后把这个过程对象传给带块的方法。

pobj = proc {|v| p v }

[1,2,3].each(&pobj)
=> 1
   2
   3

ruby 1.7 特性: 在version 1.7中，若该对象自带to_proc方法的话，就可以把它当作带"&"的参数传给带块方法(默认状态下，Proc、Method对象都有to_proc方法)。方法调用时会执行to_proc，它将返回Proc对象。

class Foo
  def to_proc
    Proc.new {|v| p v}
  end
end

[1,2,3].each(&Foo.new)

=> 1
   2
   3

带块方法的返回值与通常的方法是一样的。若块中的 break 引起中断时，将返回nil。
ruby 1.7 特性 ：若break带参数的话，该参数的值就是带块方法的返回值。

1.8呢？

yield

语法:

yield `(' [表达式 [`,' 表达式 ... ]] `)'
yield [表达式 [`,' 表达式 ... ]]

把参数传给块之后，对块进行计算。因为yield定义迭代器，所以是在方法定义内使用。

def foo
  yield(1,2)
end

foo {|a,b| p [a,b]}

对块参数进行赋值时遵从多重赋值规律。若执行yield时，方法并没有带块(不是迭代器)的话，就会引发 LocalJumpError 异常。

yield将会返回块内最后被计算的表达式的值。若因 next 引起块的运行中断的话，返回nil。

def foo
  yield 1,2,3
end

foo {|v| p v}

# => -:5: warning: multiple values for a block parameter (3 for 1)
     [1, 2, 3]

应该写成

yield [1,2,3]

或者

foo {|*v| p v}

这样才对。虽然现在使用

v = 1,2,3

这样的多重赋值还不会有警告，但最好不要使用。