©
本文档使用php.cn手册发布
例:
class Foo < Super def test : end : end
语法:
class 标识符 [`<' superclass ] 表达式.. end
语法:ruby 1.7 特性
class 标识符 [`<' superclass ] 表达式.. [rescue [error_type,..] [=> evar] [then] 表达式..].. [else 表达式..] [ensure 表达式..] end
用来定义类的内容。类名(标识符)由大写字母开头。ruby 1.7 特性：在version 1.7中，可以添加rescue/ensure部分。
类定义实际上就是把类赋值给由类名指定的常数(在Ruby中，类也是一个对象，它是Class类的实例)。
若某个类已经被定义过，此时又用相同的类名进行类定义的话，就意味着对原有的类的定义进行追加。但是若显式地标出新类的超类与原有类的超类不同时，就表示将使用原有的类名定义一个新的类(这将覆盖与类同名的常数，因此会出现警告)。
class Foo < Array def foo end end # 追加定义(即使显式地标明超类是Array，其结果也是一样) class Foo def bar end end # 定义新的类(因为超类不同) class Foo < String end # => warning: already initialized constant Foo
在类定义表达式中，self指的是该类本身，这与顶层没有什么不同，只是默认的调用限制有些许差异。可以在类定义表达式中写入任何表达式，在定义类时这些表达式将被执行。
类定义中可以出现嵌套。下例中，嵌套外侧的Foo类和内侧的Bar类之间根本没有什么继承关系之类的功能上的联系(除了常数Bar是Foo中的常数Foo:Bar之外)。
class Foo class Bar end end
ruby 1.8 特性:如果Foo类已经定义过了的话，还可以这么写。
class Foo end class Foo::Bar end
类的嵌套就是指，把与类有关的类和模块放在该类的外侧，使它们构成一个整体，借以表达某种包含关系。
# 把与NET有关的类置入NET内部 # 常使用模块来作为嵌套的外侧部分 # (Net没有实例。这主要是为了能够包含(include)Net) module Net class HTTP end class FTP end end obj = Net::HTTP.new # 或者 include Net obj = HTTP.new # 下列用法在内部类中也可使用 # 使用者只要包含(include)了File::Constants # 就可以直接使用RDONLY，而不必写File::RDONLY等。 class File module Constants RDONLY = 0 WRONLY = 1 end include Constants end File.open("foo", File::RDONLY) # 或者 include File::Constants File.open("foo", RDONLY) # 上面的只是例子。实际上，使用File.open时可以写得更简单 # 可以这么写，File.open("foo", "r")
类定义表达式没有返回值。ruby 1.7 特性:类定义表达式将返回最后被计算的式子的值。若最后的式子不返回值，就返回nil。
例:
class << obj def test : end : end
语法:
class `<<' expr 表达式.. end
语法:ruby 1.7 特性
class `<<' expr 表达式.. [rescue [error_type,..] [=> evar] [then] 表达式..].. [else 表达式..] [ensure 表达式..] end
与类定义的语法结构相同，它定义特定对象的功能。在其内部定义的方法和常数只对该特定对象有效。ruby 1.7 特性：在version 1.7中，还可以使用rescue/ensure部分。
特殊类定义表达式将返回最后被计算的式子的值。若最后的式子不返回值，就返回nil。
例:
module Foo def test : end : end
语法:
module 标识符 表达式.. end
语法:ruby 1.7 特性
module 标识符 表达式.. [rescue [error_type,..] [=> evar] [then] 表达式..].. [else 表达式..] [ensure 表达式..] end
用来定义模块的内容。模块名(标识符)由大写字母开头。ruby 1.7 特性：在version 1.7中，还可以使用rescue/ensure。
模块定义实际上就是把模块赋值给由模块名指定的常数(在Ruby中，模块也是一个对象，它是
若某个模块已经被定义过，此时又用相同的模块名来定义模块的话，就意味着对原有的模块定义进行追加。
模块定义表达式没有返回值.ruby 1.7 特性：模块定义表达式将返回最后被计算的式子的值.若该式子不返回值,则返回nil.
例:
def fact(n) if n == 1 then 1 else n * fact(n-1) end end
语法:
def 方法名 [`(' [arg ['=' default]] ... [`,' `*' arg] [',' '&' arg]`)'] 表达式.. [rescue [error_type,..] [=> evar] [then] 表达式..].. [else 表达式..] [ensure 表达式..] end
在定义语句所在的区域内定义一个方法.也就是说,若在类/模块的定义部分内定义一个方法的话,该方法就属于这个类/模块.若在顶层定义了一个方法的话,您就可以在任何地方调用它.这种方法其实就是其他语言中所说的"函数".
方法名中,除了可以使用通常的标识符以外,还可以使用可重载的操作符(例:==,+,-等等.请参考操作符表达式).
若给形参指定了默认表达式的话,在方法调用过程中如果实参被省略时,该默认表达式的值就会变成默认值(方法调用时,在方法定义内计算默认表达式的值).
若最后一个形参的前面带"*"的话,所有剩下的实参将被转为数组后传递给该参数.
例:
# 没有参数的方法。以下省略 end def foo end # 有参数的方法 def foo(arg, arg2) # 有默认参数的方法 def foo(arg = nil) # 带块 def foo(arg, &block) # 参数一应俱全 def foo(arg, arg2, arg3 = nil, *rest, &block) # 操作符表达式 def ==(other) def +(other) def *(other)
若最后一个形参前面带"&"的话,表示传递给该参数的块是一个过程对象(Proc).这是定义迭代器的一种方法.(定义迭代器的典型方法是调用yield.还可以使用Proc.new/proc等方法.)当没有给出块时,块参数的值为nil.
在方法定义中,只能以下列顺序指定形参.其中任何一项都是可选的.
例: 定义迭代器
# 使用 yield def foo # block_given? 是内部函数 # 用来判断方法有没有块 if block_given? yield(1,2) end end # 使用 Proc.new def bar if block_given? Proc.new.call(1,2) # proc.call(1,2)也是一样(proc是内部函数) end end # 应用:定义一个既能接受Proc对象 # 又能接受块的迭代器 def foo(block = Proc.new) block.call(1,2) end foo(proc {|a,b| p [a,b]}) foo {|a,b| p [a,b]} # 使用块参数 def baz(&block) if block block.call(1,2) end end
我们再举几个特殊的例子.
# 单相+/- def +@ def -@ # 给要素赋值 def foo=(value) # obj.foo = value # [] と []= def [](key) # obj[key] def []=(key, value) # obj[key] = value def []=(key, key2, value) # obj[key, key2] = value # 后引号表示法 def `(arg) # `arg` 或 %x(arg)
因为后引号表示法与方法密切相关,所以可以进行再定义.通常情况下,不应该对该方法进行再定义.偶尔OS(SHELL)命令的运作不太正常时,可以使用这种方法.
为了捕捉在方法运行时发生的异常,可以使用同begin一样的rescue,else或ensure语句.
方法定义表达式不会返回值.ruby 1.7 特性:方法定义表达式返回nil.
除了特殊方法定义以外,方法定义表达式不能进行嵌套.
ruby 1.7 特性: 在1.7 以后的版本中,就可以进行嵌套了.只有嵌套外侧的方法被执行时,嵌套方法才会被定义.除此以外,它和普通的方法定义表达式没有区别.请参考下例.
class Foo def foo def bar p :bar end end def Foo.method_added(name) puts "method \"#{name}\" was added" end end obj = Foo.new obj.bar rescue nil # => undefined method `bar' for # obj.foo # => method "foo" was added obj.foo # => warning: method redefined; discarding old bar Foo.new.bar # => :bar (在其他实例中,嵌套方法也已完成定义)
在version 1.6之前的版本中,若想达到相同的目的就必需使用instance_eval(此时特殊方法已被定义,因此稍有不同).
class Foo def foo instance_eval <<-END def bar p :bar end END end end obj = Foo.new def obj.singleton_method_added(name) puts "singleton method \"#{name}\" was added" end # => singleton method "singleton_method_added" was added obj.bar rescue nil # => undefined method `bar' for # obj.foo # => singleton method "bar" was added obj.foo # => warning: method redefined; discarding old bar # => singleton method "bar" was added Foo.new.bar # => undefined method `bar' for #
还可以这么写.
class Foo def foo instance_eval { def bar p :bar end } end end
调用方法时,将按照下列顺序依此计算各个表达式.
在方法内,根据实际情况来计算这些部分,包括参数的默认表达式在内.
方法的返回值就是传给return的值.若没有调用return时,将返回在ensure部分之前最后计算的式子的值.
若最后的式子(例如while等)没有返回值,则返回nil.
在定义某方法之前,是不能使用该方法的.例如
foo def foo print "foo\n" end
调用未定义的方法会引发NameError异常.
例:
def foo.test print "this is foo\n" end
语法:
def 表达式 `.' 标识符 [`(' [参数 [`=' default]] ... [`,' `*' 参数 ]`)'] 表达式.. [rescue [error_type,..] [=> evar] [then] 表达式..].. [else 表达式..] [ensure 表达式..] end
特殊方法就是专属于某个对象的方法.特殊方法的定义可以嵌套.
类的特殊方法将被该类的子类所继承.换言之,类的特殊方法所起到的作用,与其他面向对象系统中的类方法的作用是相同的.
特殊方法定义表达式不会返回值.ruby 1.7 特性:特殊方法定义表达式返回nil.
Ruby中的类方法是指类的特殊方法.在Ruby中,类也是对象.因此它就可以像普通对象一样来定义特殊方法.
因此,若能在类对象中定义方法的话,该方法就会成为类方法.具体的定义方法如下(模块也一样).
# 特殊方法方式. class Hoge def Hoge.foo end end # 在类定义的外侧也行 def Hoge.bar end # 若使用下面的方法的话,即使类名改变了,也不必更改方法定义 class Hoge def self.baz 'To infinity and beyond!' end end # 特殊类方式.适合于大批量地定义方法 class << Hoge def bar 'bar' end end # 若把模块extend到类的话,模块的实例方法 # 就会变成类方法 module Foo def foo end end class Hoge extend Foo end
请参考Object#extend来了解extend.
调用方法时,会受到以下三种限制,即public、private、protected.
public类型,则没有任何限制.private类型,则只能在函数中调用.protected类型,则只能在该方法所属对象的方法定义表达式内使用.例: protected的可用性