Day 4：Ruby 模块

2016年9月7日 上午10:18 ***

介绍一种跟类相似的构造：模块（module）。在设计程序的时候，我们会把大的组件分割成小块，你可以混合与匹配对象的行为。

跟类差不多，模块也捆绑方法与常量。不一样的是，模块没有实例。你可以把拥有特定功能的模块放到类或某个特定的对象里使用。

Class 这个类是 Module 类的一个子类，也就是所有的 class 对象应该也是一个 module 对象。

上午10:26 ***

创建与使用模块

上午10:26 ***

module MyFirstModule
  def say_hello
  puts 'hello'
  end
end

我们创建了类以后可以去创建这个类的实例，实例可以执行类里面的实例方法。不过模块是没有实例的，模块可以混合（mixed in，mix-in，mixin）到类里面，用的方法是 include 还有 prepend 。这样类的实例就可以使用在模块里面定义的实例方法了。

使用一下上面定义的那个模块：

class ModuleTester
  include MyFirstModule
end

mt = ModuleTester.new
mt.say_hello

上面的 ModuleTester 对象调用了 say_hello 这个方法，这样会输出一个 hello 。这个方法是混合到 ModuleTester 类里面的 MyFirstModule 里定义的实例方法。

在类里混合使用模块很像是去继承一个 superclass 。比如 B 类继承了 A 类，这样 B 类的实例就可以调用来自 A 类的实例方法。再比如 C 类混合了模块 M，这样 C 类的实例就可以调用在模块 M 里定义的方法。继承类与混合模块的区别是，你可以在一个类里混合使用多个模块，你不能让一个类去继承多个类。

模块可以让我们在多个类之间共用它的代码，因为任何的类都可以混合使用同一个模块。

创建一个模块

模块给我们提供了收集与封装行为的方法。下面我们可以写一个模块，去封装一些像堆（stack）的特性，然后把模块混合到一个或多个类里面，这样模块里的行为就会传授给对象。

堆（stack）是一种数据格式，后进来的，先出去（LIFO：last in, first out）。比如一堆盘子，用的第一个盘子，是最后一次放到这堆里的那个。经常跟堆一起讨论的还有个概念：队列（queue），它是先进来的，先出去（FIFO），比如在民政局窗口前排的队，排在第一位置上的人最先办完手续。

先把下面代码放到 stacklike.rb 文件里：

module Stacklike
  def stack
    @stack ||= []
  end

  def add_to_stack(obj)
    stack.push(obj)
  end

  def take_from_stack
    stack.pop
  end
end

在上面的 Stacklike 模块里，我们使用了一个数组来表示堆，这个数组会存储在一个实例变量里面，名字是 @stack，这个实例变量可以通过 stack 这个方法得到。这个方法使用了条件设置变量，||= 是一个操作符，只有变量不是 nil 或 false 的时候，才会让这个变量的值等于一个特定的值。这里就是第一次调用 stack 的时候，它会设置 @stack 让它等于一个空白的数组，后续再次调用的时候，@stack 已经有值了，也就会去返回它的值。

调用 add_to_stack 方法会把一个对象添加到堆里面，就是会把对象添加到 @stack 数组的最后。take_from_stack 会删除掉数组里的最后一个对象。这些方法里用的 push 还有 pop ，它们是 Array 类里的实例方法。

我们定义的这个 Stacklike 模块，其实就是有选择的实施了已经在 Array 对象里存在的一些行为，添加一个元素到数组的最后，删除数组里的最后一个元素。相比堆，数组更灵活一些，堆不能干所有数组能干的事。比如你可以删除掉数组里的任意顺序的项目，在堆里就不行，你只能删除掉最近添加进来的元素。

现在我们定义好了一个模块，它实施了堆的一些行为，也就是管理一些项目，新的项目可以添加到最后，最近添加进来的可以被删除掉。下面再看一下怎么样使用模块。

在类里混合模块

做个实验，创建一个文件，名字是 stack.rb，添加下面这段代码：

require_relative 'stacklike'

class Stack
  include Stacklike
end

这里混合用的方法是 include ，把 Stacklike 这个模块混合到了 Stack 这个类里，这样 Stack 类的对象就会拥有在 Stacklike 模块里定义的方法了。

使用 require 或 load 的时候，要加载的东西放到了一组引号里面，但是使用 include 与 prepend 的时候加载的东西不需要使用引号。因为 require 与 load 要使用字符串作为它们的参数值，include 载入的是模块的名字，模块的名字是常量。require 与 load 要找到在磁盘上的文件，include 与 prepend 会在内存里操作。

类的名字用的是名词，模块的名字用的是形容词。Stack objects are stacklike 。

做个实验：

s = Stack.new

s.add_to_stack('项目 1')
s.add_to_stack('项目 2')
s.add_to_stack('项目 3')

puts '当前在堆里的对象：'
puts s.stack

taken = s.take_from_stack
puts '删除了对象：'
puts taken
puts '现在堆里是：'
puts s.stack

执行一下会输出：

当前在堆里的对象：
项目 1
项目 2
项目 3
删除了对象：
项目 3
现在堆里是：
项目 1
项目 2

继续使用模块

再做个实验，创建一个文件，名字是 cargohold.rb（飞机货舱），代码如下：

require_relative 'stacklike'

class Suitcase
end

class CargoHold
  include Stacklike

  def load_and_report(obj)
    print 'loading object：'
    puts obj.object_id
    add_to_stack(obj)
  end

  def unload
    take_from_stack
  end
end

ch = CargoHold.new

sc1 = Suitcase.new
sc2 = Suitcase.new
sc3 = Suitcase.new

ch.load_and_report(sc1)
ch.load_and_report(sc2)
ch.load_and_report(sc3)

first_unloaded = ch.unload
print '第一个下飞机的行里是：'
puts first_unloaded.object_id

执行它的结果是：

loading object：70328907390400
loading object：70328907390380
loading object：70328907390360
第一个下飞机的行里是：70328907390360

下午12:00 ***

模块，类与方法查找

下午12:06 ***

对象收到发送给它的信息以后，它会试着去执行跟信息一样的方法，方法可以是对象所属的类里面定义的，或者这个类的 superclass，或者是混合到这个类里的模块提供的。发送信息给对象究竟发生了什么？

方法查找

下面这个例子演示了加载模块与类的继承：

module M
  def report
    puts "'report' 方法在模块 M 里"
  end
end

class C
  include M
end

class D < C
end

obj = D.new
obj.report

report 这个实例方法是在模块 M 里定义的，在 C 类里面混合了模块 M ，D 类是 C 类的子类，obj 是 D 类的一个实例，obj 这个对象可以调用 report 方法。

从对象的视角来看一下，假设你就是一个对象，有人给你发了个信息，你得想办法作出回应，想法大概像这样：

• 我是个 Ruby 对象，别人给我发了个 'report' 信息，我得在我的方法查找路径里，试着去找一个叫 report 的方法，它可能在一个类或者模块里。
• 我是 D 类的一个实例。D 类里有没有 report 这个方法？
• 没有
• D 类有没有混合使用模块？
• 没有
• D 类的超级类（superclass）C，里面有没有定义 report 这个实例方法？
• 没有
• C 类里混合模块了没？
• 是的，混合了模块 M
• 那 M 模块里有没有 report 这个方法？
• 有
• 好地，就调用一下这个方法。

找到了这个方法搜索就结束了，没找到就会触发错误，这个错误是用 method_missing 方法触发的。

同名方法

同一个名字的方法在任何时候，在每个类或模块里只能出现一次。一个对象会使用它最先在找到的方法。

做个实验：

module M
  def report
    puts '在模块 M 中的 report'
  end
end

module N
  def report
    puts '在模块 N 中的 report'
  end
end

class C
  include M
  include N
end

c = C.new
c.report

执行它的结果会是：

在模块 N 中的 report

多次加载同一个模块是无效的，这样试一下：

class C
  include M
  include N
  include M
end

执行的结果仍然会是：

在模块 N 中的 report

下午12:49 ****

prepend

下午1:40 ***

使用 prepend 加载的模块，对象会先使用。也就是如果一个方法在类与模块里都定义了，会使用用了 prepend 加载的模块里的方法。

来看个例子：

module MeFirst
  def report
    puts '来自模块的问候'
  end
end

class Person
  prepend MeFirst
  def report
    puts '来自类的问候'
  end
end

p = Person.new
p.report

执行的结果会是：

来自模块的问候

super

做个实验：

module M
  def report
    puts '在模块 M 里的 report 方法'
  end
end

class C
  include M

  def report
    puts 'C 类里的 report 方法'
    puts '触发上一级别的 report 方法'
    super
    puts "从调用 super 那里回来了"
  end
end

c = C.new
c.report

执行的结果是：

C 类里的 report 方法
触发上一级别的 report 方法
在模块 M 里的 report 方法
从调用 super 那里回来了

c 是 C 类的一个实例，c.report 是给 c 发送了一个 report 信息，收到以后开始查找方法，先找到的 C 类，这里定义了 report 方法，所以会去执行它。

在 C 类里的 report 方法里，调用了 super，意思就是即使对象找到了跟 report 这个信息对应的方法，它还必须继续查找下一个匹配的 report 方法，下一个匹配是在模块 M 里定义的 report 方法，也就会去执行一下它。

再试一个使用 super 的例子：

class Bicycle
  attr_reader :gears, :wheels, :seats

  def initialize(gears = 1)
    @wheels = 2
    @seats = 1
    @gears = gears
  end
end

class Tandem < Bicycle
  def initialize(gears)
    super
    @seats = 2
  end
end

上面有两个类，Bicycle 自行车，Tandem 双人自行车，Tandem 继承了 Bicycle 类。在 Tandem 的 initialize 方法里用了一个 super ，会调用 Bicycle 类里的 initialize 方法，也就是会设置一些属性的默认的值。双人自行车有两个座位，所以我们又重新在 Tandem 的 initialize 方法里设置了一下 @seats 的默认的值。

super 处理参数的行为：

• 不带参数调用 — super，super 会自动转发参数传递给它调用的方法。
• 带空白参数的调用 — super()，super 不会发送参数。
• 带特定参数的调用 — super(a, b, c)，super 只会发送这些参数。

下午2:23 ***

method_missing 方法

下午 14:35 ***

Kernel 模块提供了一个实例方法叫 method_missing，如果对象收到一个不知道怎么响应的信息，就会调用这个方法。

试一下：

>> obj = Object.new
=> #<Object:0x007fdef1958fa8>
>> obj.blah
NoMethodError: undefined method `blah' for #<Object:0x007fdef1958fa8>
 from (irb):2
 from /usr/local/bin/irb:11:in `<main>'

我们可以覆盖 method_missing：

>> def obj.method_missing(m, *args)
>> puts "你不能在这个对象上调用 #{m}，试试别的吧。"
>> end
=> :method_missing
>> obj.blah
你不能在这个对象上调用 blah，试试别的吧。
=> nil

组合 method_missing 与 super

一般我们会拦截未知的信息，然后决定到底怎么去处理它，可以处理，也可以把它发送给原来的 method_missing 。使用 super 就很容易实现，看个例子：

class Student
  def method_missing(m, *args)
    if m.to_s.start_with?('grade_for_')
      # return the appropriate grade, based on parsing the method name
    else
      super
    end
  end
end

上面的代码，如果调用的方法是用 grade_for 开头的就会被处理，比如 grade_for_english 。如果不是，就会调用原始的 method_missing 。

再试一个复杂点的例子。比如我们要创建一个 Person 类，这个类可以这样用：

j = Person.new("John")
p = Person.new("Paul")
g = Person.new("George")
r = Person.new("Ringo")

j.has_friend(p)
j.has_friend(g)
g.has_friend(p)
r.has_hobby("rings")

Person.all_with_friends(p).each do |person|
  puts "#{person.name} is friends with #{p.name}"
end

Person.all_with_hobbies("rings").each do |person|
  puts "#{person.name} is into rings"
end

我们想要输出的东西像这样：

John is friends with Paul
George is friends with Paul
Ringo is into rings

一个人可以有朋友和爱好，Person 可以找出某个人的所有的朋友，或者拥有某个爱好的所有的人。这两个功能是用 all_with_friends 还有 all_with_hobbies 这两个方法实现的。

Person 类上的 all_with_* 方法可以使用 method_missing 改造一下，在类里定义一段代码：

class Person
  def self.method_missing(m, *args)
    # code here
  end
end

m 是方法的名字，它可以是用 all_with 开头的，也可以不是，如果是我们就去处理一下它，如果不是就交给原始的 method_missing 。再这样修改一下：

class Person
  def self.method_missing(m, *args)
    method = m.to_s
    if method.start_with?('all_with_')
      # 在这里处理请求
    else
      super
    end
  end
end

• Person 对象要跟踪它所有的朋友与爱好
• Person 类跟踪所有的人
• 每个人都有个名字

class Person
  PEOPLE = []
  attr_reader :name, :hobbies, :friends

  def initialize(name)
    @name = name
    @hobbies = []
    @friends = []
    PEOPLE << self
  end

  def has_hobby(hobby)
    @hobbies << hobby
  end

  def has_friend(friend)
    @friends << friend
  end

每次实例化一个新人都会把它放到 PEOPLE 这个数组里。还有几个读属性，name，hobbies，friends。

initialize 方法里有个 name 变量，把它放到了 @name 属性里，同时也会初始化 hobbies 和 friends ，这两个属性在 has_hobby 与 has_friend 方法里用到了。

再完成 Person.method_missing ：

def self.method_missing(m, *args)
  method = m.to_s
  if method.start_with?('all_with_')
    attr = method[9..-1]
    if self.public_method_defined?(attr)
      PEOPLE.find_all do |person|
        person.send(attr).include?(args[0])
      end
    else
      raise ArgumentError, "Can't find #{attr}"
    end
  else
    super
  end
end

全部代码如下：

class Person
  PEOPLE = []
  attr_reader :name, :hobbies, :friends

  def initialize(name)
    @name = name
    @hobbies = []
    @friends = []
    PEOPLE << self
  end

  def has_hobby(hobby)
    @hobbies << hobby
  end

  def has_friend(friend)
    @friends << friend
  end

  def self.method_missing(m, *args)
    method = m.to_s
    if method.start_with?('all_with_')
      attr = method[9..-1]
      if self.public_method_defined?(attr)
        PEOPLE.find_all do |person|
          person.send(attr).include?(args[0])
        end
      else
        raise ArgumentError, "Can't find #{attr}"
      end
    else
      super
    end
  end
end

j = Person.new("John")
p = Person.new("Paul")
g = Person.new("George")
r = Person.new("Ringo")

j.has_friend(p)
j.has_friend(g)
g.has_friend(p)
r.has_hobby("rings")

Person.all_with_friends(p).each do |person|
  puts "#{person.name} is friends with #{p.name}"
end

Person.all_with_hobbies("rings").each do |person|
  puts "#{person.name} is into rings"
end

执行的结果会是：

John is friends with Paul
George is friends with Paul
Ringo is into rings

下午3:53 ***

Ruby