单件方法听上去挺玄乎，但理解起来其实不复杂。

Ruby是一门非常灵活的语言。它允许我们为单个对象单独定义方法。这种只针对某一个对象生效的方法，就叫做单件方法。

看一段示例代码就清楚了：

str = “just a regular string”

def str.title?
  self.upcase == self
end

str.title? # => false
str.methods.grep(/title?/) # => [:title?]
str.singleton_methods  #=> [:title?]

str.class # => String
String.title? #=> NoMethodError

从这个例子可以看出，title 只属于 str 这个对象。

即使 str.class 是 String，String 本身也不能调用这个方法。

除了用 def 直接定义，Ruby 还提供了 Object#define_singleton_method 方法来完成同样的事情，这里就不展开了。

单件方法与类方法

回顾一下基础概念：Ruby 中的类本身也是对象，类名本质上就是一个常量。

所以，在类上调用方法的本质，跟在普通对象上调用方法是一回事。

类方法的实质，其实就是这个类的单件方法。

来对比一下它们的定义方式：

def obj.a_singleton_method; end
def MyClass.another_class_method; end

可以看到，用的都是同样的 def 关键词。

通用的语法是这样：

def object.method
  #方法主体
end

这里的 object 可以是对象的引用，也可以是常量类名，甚至可以是 self。

这一点在理解 Ruby 的对象模型时非常关键。

类宏 attr_accessor

Ruby 的对象本身并没有“属性”这个概念。

如果希望对象拥有类似属性的行为，就需要自己定义读方法和写方法，也就是 Ja va 或 Objective-C 里常说的 getter 和 setter。

最直接的做法是这样的：

class MyClass
  def my_attribute=(value)
    @my_attribute =value  
  end
  def my_attribute
    @my_attribute
  end
end

obj = MyClass.new
obj.my_attribute = ‘x'
obj.my_attribute  #=> ‘x'

如果每个属性都手动写读方法和写方法，代码会非常冗长。

这时候就该三个“类宏”登场了：

• Module#attr_reader —— 只生成读方法
• Module#attr_writer —— 只生成写方法
• Module#attr_accessor —— 同时生成读方法和写方法

实际用起来是这个样子：

class MyClass
  attr_accessor :my_attribue
end

一行代码就能搞定。

相比手写 getter/setter，它简洁得多，而且使用方法跟之前完全一致。

单件类

Ruby 的方法查找顺序有一个广为人知的原则：先向右，再向上。

意思是先找到对象的类，在类的实例方法中查找；如果没找到，再顺着祖先链继续往上找。

问题来了：单件方法是针对单个对象定义的，那它在方法查找时应该排在什么位置？

class MyClass
  def my_method; end
end

obj = MyClass.new

def obj.my_singleton_method; end

首先，单件方法不会存在于 obj 这个对象本身，因为对象不是类。

其次，它也不会存在于 MyClass 中。否则，所有 MyClass 的实例都能调用它，那它就不叫“单件”了。

同样，它也不能挂在 Object 这些祖先链的类上。

正确答案是：单件方法存放在一个特殊的类中，这个类就是单件类（也叫元类或本征类）。

打开单件类

Ruby 提供了两种获取单件类引用的方式。

第一种是用经典的 class 关键词配合特殊语法：

class << an_object
  # 自己的代码
end

obj = Object.new
singleton_class = class << obj
  self
end
singleton_class.class # => Class

第二种更直接，通过 Object#singleton_class 方法获得：

“abc”.singleton_class  # => #>

单件类的特性

• 每个单件类只有一个实例——这也是它叫“单件”的原因，而且它不能被继承。
• 单件类是对象的单件方法真正存活的地方。
• 引入单件类后，方法查找顺序会发生变化。

具体来说，Ruby 在查找方法时，会先从对象的单件类开始。

如果在单件类中没有找到，才会继续沿着普通类及祖先链去查找。

换句话说，单件类成了方法查找的第一站。

用一个例子来验证：

class C
  def a_method
    ‘C#a_method()'
  end
end

class D < C; end

obj = D.new

然后打开 obj 的单件类，定义一个单件方法：

class << obj
  def a_singleton_method
    ‘obj#a_singleton_method()'
  end
end

obj.singleton_class.superclass #=> D

注意到 obj.singleton_class.superclass 返回了 D。

这正是我们期望的结果：单件类被插入到对象和它的普通类之间。

这样一来，整个方法查找顺序就清晰了：从单件类开始，然后进入类及祖先链的查找流程。

《夸克》非常好用的免费AI浏览器

下载APP查看