Ruby Modul (Module)

Syntax

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

Modulkonstantennamen sind ähnlich wie Klassenkonstantennamen, sie beginnen mit einem Großbuchstaben. Die Methodendefinitionen sehen auch ähnlich aus: Modulmethodendefinitionen ähneln Klassenmethodendefinitionen.

Durch Klassenmethoden können Sie den Modulnamen und einen Punkt vor dem Namens des Klassenmethods platzieren, um Modulmethoden aufzurufen. Sie können Modulnamen und zwei Doppelpunkte verwenden, um Konstanten zu referenzieren.

在线示例

#!/usr/bin/ruby
　
# Definiert im Datei trig.rb
　
module Trig
　　　PI =　3.141592654
　　　def Trig.sin(x)
　　　# ..
　　　end
　　　def Trig.cos(x)
　　　# ..
　　　end
end

Wir können mehrere Module mit gleichen Namen aber verschiedenen Funktionen definieren:

在线示例

#!/usr/bin/ruby
　
# Definiert im Datei moral.rb
　
module Moral
　　　VERY_BAD = 0
　　　BAD =　1
　　　def Moral.sin(badness)
　　　# ...
　　　end
end

wie Klassenmethoden, wenn Sie eine Methode in einem Modul definieren, können Sie nach dem Modulnamen einen Punkt und den Methodennamen angeben.

Ruby require Zeile verwenden

Anweisungen ähnlich wie in C und C++ encompassen die include-Anweisungen in Ruby und die import-Anweisungen in Java. Wenn ein Drittanbieter-Programm auf irgendein definiertes Modul zugreifen möchte, kann es einfach Ruby verwenden require Anweisung, um Moduldateien zu laden:

Syntax

Syntax

require filename

Hierbei ist die Dateierweiterung .rb nicht notwendig.

在线示例

$LOAD_PATH << '.'
　
require 'trig.rb'
require 'moral'
　
y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)

Hier verwenden wir $LOAD_PATH << '.' Lassen Sie Ruby wissen, dass es in dem aktuellen Verzeichnis nach referenzierten Dateien suchen muss. Wenn Sie $LOAD_PATH nicht verwenden möchten, können Sie require_relative um Dateien aus einem relativen Verzeichnis zu referenzieren.

Hinweis:Hier sind die Dateien enthalten die gleichen Funktionsnamen. Daher führt dies zu einer Verwirrung bei der Referenzierung der Aufrufprogramme, aber Module vermeiden diese Verwirrung und wir können die Funktionen mit dem Namen des Moduls aufrufen.

Ruby include Zeile verwenden

Sie können Module in der Klasse einbetten. Um Module in der Klasse einzubetten, können Sie im Klassendefinition include Zeile referenziert werden:

Syntax

include modulename

Wenn das Modul in einer separaten Datei definiert ist, muss es vor dem Einbinden des Moduls mit require Zeile referenziert diese Datei.

在线示例

Angenommen, der folgende Modul ist in support.rb im Datei.

module Week
　　　FIRST_DAY = "Sonntag"
　　　def Week.weeks_in_month
　　　　　　puts "Sie haben vier Wochen im Monat"
　　　end
　　　def Week.weeks_in_year
　　　　　　puts "Sie haben　52　Wochen im Jahr"
　　　end
end

Jetzt können Sie den Modul in der Klasse wie folgt referenzieren:

在线示例

#!/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

Dies führt zu folgendem Ergebnis:

Sonntag
Sie haben vier Wochen im Monat
Sie haben　52　Wochen im Jahr
Sonntag
120

Mixins in Ruby

Bevor Sie dieses Kapitel lesen, müssen Sie eine Grundkenntnis der objektorientierten Konzepte haben.

Wenn eine Klasse Eigenschaften von mehreren Elternklassen vererben kann, wird sie als Mehrfachvererbung angezeigt.

Ruby unterstützt keine Mehrfachvererbung direkt, aber Ruby Module haben eine weitere magische Funktion. Sie beseitigt fast den Bedarf an Mehrfachvererbung und bietet eine Funktion namens mixin der Anlage.

Ruby hat keine echte Mehrfachvererbung implementiert, sondern verwendet die Technik der Mixins als Ersatz. Durch das Einbinden von Modulen in die Klassendefinition werden die Methoden des Moduls in die Klasse eingebunden.

让我们看看下面的示例代码，深入了解 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 。