module Ruby (Module)

grammaire

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

Module constantes nommées et constantes de classe similaire nommés, en commençant par une lettre majuscule. définition de la méthode ressemble à: approche modulaire similaire pour définir les définitions de méthodes de classes.

Grâce aux méthodes de classe, vous pouvez placer le nom du module et un point devant le nom de la classe de la méthode à appeler l'approche modulaire, vous pouvez utiliser le nom du module et deux deux-points pour faire référence à une constante.

Exemples

#!/usr/bin/ruby

# 定义在 trig.rb 文件中的模块

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

Nous pouvons définir plusieurs fonctions avec le même nom mais différents modules fonctionnels:

#!/usr/bin/ruby

# 定义在 moral.rb 文件中的模块

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

Comme les méthodes de classe, lorsque vous définissez une méthode dans un module, vous pouvez spécifier le nom du module suivi d'un point après point suivi du nom de la méthode.

Rubyexige la déclaration

exige la déclaration est similaire à C et C ++, et comprennent des énoncés dans l'instruction import Java. Si un programme tiers que vous souhaitez utiliser l' un des modules ont été définis, vous pouvez simplement utiliser leRubyexige la déclaration de charger le fichier de module:

grammaire

require filename

Ici, l'extension de fichier.RB pas nécessaire.

Exemples

$ LOAD_PATH << '.'

require 'trig.rb'
exiger «morale»

y = Trig.sin (Trig :: PI / 4)
actes répréhensibles = Moral.sin (Moral :: VERY_BAD)

Ici, nous utilisons$ LOAD_PATH << '.' Que Ruby sait que nous devons rechercher le fichier référencé dans le répertoire courant.Si vous ne souhaitez pas utiliser $ LOAD_PATH, vous pouvez utiliserrequire_relative pour référencer un fichier à partir d' un répertoire relatif.

Remarque: Ici, le fichier contient le même nom de fonction.Donc, cela va conduire à l'obscurcissement se référant au programme appelant, mais modules éviter ce obfuscation de code, et nous pouvons utiliser le nom du module pour appeler la fonction appropriée.

Rubyinclude

Vous pouvez intégrer un module dans une classe. Afin d'intégrer dans le module de classe, vous pouvez utiliserincluredes déclarations dans votre classe:

grammaire

include modulename

Si le module est défini dans un fichier séparé, donc avant que vous devez utiliser le module embarquéexigerdes états de référence du fichier.

Exemples

En supposant que les modules suivants écrits dans le fichiersupport.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

Vous pouvez maintenant référencer le module dans la classe, comme suit:

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

On obtient les résultats suivants:

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

Ruby dans Mixins

Avant de lire cette section, vous aurez besoin d'une compréhension préliminaire des concepts orientés objet.

Quand une classe peut être plus d'une classe parent lorsque la classe d'entités hérite de la classe est affiché comme l'héritage multiple.

Ruby ne supporte pas directement l'héritage multiple, mais le module Ruby (Module) a encore des caractéristiques fantastiques. Elle élimine pratiquement la nécessité d'héritage multiple, il est prévu un appareil appelémixins.

Ruby n'a pas vraiment réaliser mécanisme d'héritage multiple, mais a adopté la technologie mixin comme un substitut. Les modules comprennent la définition de classe, l'approche du module de mélanger dans la classe.

Regardons l'exemple de code suivant, la compréhension en profondeur de 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

• Un module est composé par le procédé de A1 et A2.
• Le module B par la méthode de la composition B1 et B2.
• classe Sample contient des modules A et B.
• classe Sample peut accéder à tous les quatre méthodes, à savoir, a1, a2, b1 et b2.
Ainsi , vous pouvez voir que l'échantillon de la classe hérite de deux modules, vous pouvez dire l'échantillon de classe utiliser l' héritage oumixin multiple.
Précédent: bloc Ruby
Suivant: Ruby String (String)