方法调用

• super
• 带块的方法调用
• yield

例:

foo.bar()
foo.bar
bar()
print "hello world\n"
print
Class::new

语法:

[表达式  `.'] 标识符 [`(' 表达式 ... [`*' [表达式]],[`&' 表达式] `)']
[表达式 `::'] 标识符 [`(' 表达式 ... [`*' [表达式]],[`&' 表达式] `)']

方法调用表达式表示调用被调(receiver,"."左侧表达式的值)的方法。若未指定被调，则调用self的方法。

"."与"::"的意义大体相同。但表示常数时，必须使用"::"(例：Math::PI，Errno::ERANGE)。若写成

Klass::Foo

的话，通常会被认为是常数。请注意，通常是将"::"用作类方法的调用。若方法名是以大写字母开始的时候，要写成

Klass.Foo

或者写成

Klass::Foo()

但要用括号显式地表明这是方法调用。

方法名中除了通常的标识符以外，还可以添加"?"或"!"等后缀。通常在布尔型(返回真或伪的方法)方法名后添加"?"，在比同名(无"!")方法更具破坏性的方法名(例：tr和tr!)后添加"!"。

若最后一个参数带"*"的话，将会先展开该参数的值，然后才传递。也就是：

foo(1,*[2,3,4])
foo(1,*[])

和下例

foo(1,2,3,4)
foo(1)

等效。

若最后一个参数带"&"，则该参数指定的过程对象(Proc)以及方法对象(Method)等会被当作一个块传递给方法。详情请参考迭代器。

方法调用时，private方法只能用函数形式(省略被调的形式)来调用。而protected方法只能在拥有该方法的对象的方法定义表达式内进行调用。(请参考方法调用的限制)

super

例:

super
super(1,2,3)

语法:

super
super(表达式, ... )

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

例:

class Foo
  def foo(arg=nil)
    p arg
  end
end

class Bar < Foo
  def foo(arg)
    super(5)       # 以5作为参数进行调用
    super(arg)     # 以5作为参数进行调用
    super          # 以5作为参数进行调用，super(arg)的简写
    arg = 1
    super          # 以1作为参数进行调用，super(arg)的简写
    super()        # 无参数的调用
  end
end
Bar.new.foo 5

带块的方法调用

例:

[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带参数的话，该参数的值就是带块方法的返回值。

yield

例:

yield data

语法:

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

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

def foo
  yield(1,2)
end

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

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

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

ruby 1.7 特性 :若next带参数的话，该参数的值就是yield的返回值。

ruby 1.8 特性 ：关于块参数的交付问题，以后可能会对下述内容进行变更(会发出警告)。

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

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