Ruby 模块(Module)

模块(Module)是一种把办法、类和常量组合在一起的办法。模块(Module)为您供给了两大优点。

  • 模块供给了一个命名空间和防止姓名抵触。
  • 模块完成了 mixin 设备。

模块(Module)界说了一个命名空间,相当于一个沙盒,在里面您的办法和常量不会与其他当地的办法常量抵触。

模块相似与类,但有一下不同:

  • 模块不能实例化
  • 模块没有子类
  • 模块只能被另一个模块界说

语法

module Identifier
   statement1
   statement2
   ...........
end

模块常量命名与类常量命名相似,以大写字母最初。办法界说看起来也相似:模块办法界说与类办法界说相似。

经过类办法,您能够在类办法称号前面放置模块称号和一个点号来调用模块办法,您能够运用模块称号和两个冒号来引证一个常量。

实例

#!/usr/bin/ruby

# 界说在 trig.rb 文件中的模块

module Trig
   PI = 3.141592654
   def Trig.sin(x)
   # ..
   end
   def Trig.cos(x)
   # ..
   end
end

咱们能够界说多个函数称号相同可是功用不同的模块:

#!/usr/bin/ruby

# 界说在 moral.rb 文件中的模块

module Moral
   VERY_BAD = 0
   BAD = 1
   def Moral.sin(badness)
   # ...
   end
end

就像类办法,当您在模块中界说一个办法时,您能够指定在模块称号后跟着一个点号,点号后跟着办法名。

Ruby require 句子

require 句子相似于 C 和 C++ 中的 include 句子以及 Java 中的 import 句子。假如一个第三方的程序想要运用任何已界说的模块,则能够简略地运用 Ruby require 句子来加载模块文件:

语法

require filename

在这里,文件扩展名 .rb 不是必需的。

实例

$LOAD_PATH << '.'

require 'trig.rb'
require 'moral'

y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)

在这里,咱们运用 $LOAD_PATH << '.' 让 Ruby 知道有必要在当时目录中查找被引证的文件。假如您不想运用 $LOAD_PATH,那么您能够运用 require_relative 来从一个相对目录引证文件。

留意:在这里,文件包括相同的函数称号。所以,这会在引证调用程序时导致代码含糊,可是模块防止了这种代码含糊,并且咱们能够运用模块的称号调用恰当的函数。

Ruby include 句子

您能够在类中嵌入模块。为了在类中嵌入模块,您能够在类中运用 include 句子:

语法

include modulename

假如模块是界说在一个独自的文件中,那么在嵌入模块之前就需求运用 require 句子引证该文件。

实例

假定下面的模块写在 support.rb 文件中。

module Week
   FIRST_DAY = "Sunday"
   def Week.weeks_in_month
      puts "You have four weeks in a month"
   end
   def Week.weeks_in_year
      puts "You have 52 weeks in a year"
   end
end

现在,您能够在类中引证该模块,如下所示:

#!/usr/bin/ruby
$LOAD_PATH << '.'
require "support"

class Decade
include Week
   no_of_yrs=10
   def no_of_months
      puts Week::FIRST_DAY
      number=10*12
      puts number
   end
end
d1=Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months

这将发生以下成果:

Sunday
You have four weeks in a month
You have 52 weeks in a year
Sunday
120

Ruby 中的 Mixins

在阅览本节之前,您需求开端了解面向目标的概念。

当一个类能够从多个父类承继类的特性时,该类显现为多重承继。

Ruby 不直接支撑多重承继,可是 Ruby 的模块(Module)有另一个奇特的功用。它简直消除了多重承继的需求,供给了一种名为 mixin 的设备。

Ruby 没有真实完成多重承继机制,而是选用成为mixin技能作为替代品。将模块include到类界说中,模块中的办法就mix进了类中。

让咱们看看下面的示例代码,深化了解 mixin:

module A
   def a1
   end
   def a2
   end
end
module B
   def b1
   end
   def b2
   end
end

class Sample
include A
include B
   def s1
   end
end

samp=Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1
  • 模块 A 由办法 a1 和 a2 组成。
  • 模块 B 由办法 b1 和 b2 组成。
  • 类 Sample 包括了模块 A 和 B。
  • 类 Sample 能够拜访一切四个办法,即 a1、a2、b1 和 b2。
  • 因而,您能够看到类 Sample 承继了两个模块,您能够说类 Sample 运用了多重承继或 mixin