Ruby Module

Un Module est une façon de regrouper des méthodes, des classes et des constantes. Les Modules vous offrent deux avantages majeurs.

  • Les modules fournissent unespace de nomset évitent les conflits de noms.
  • Les modules implémentent un mécanisme demixin.

Un Module définit un espace de noms, qui agit comme un bac à sable, dans lequel vos méthodes et constantes n'entrent pas en conflit avec celles d'ailleurs.

Les modules sont similaires aux classes, mais présentent les différences suivantes :

  • Les modules ne peuvent pas être instanciés
  • Les modules n'ont pas de sous-classes
  • Les modules ne peuvent être définis que par un autre module

Syntaxe

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

Les constantes de module sont nommées comme les constantes de classe, en commençant par une lettre majuscule. Les définitions de méthodes sont similaires aussi : les définitions de méthodes de module sont similaires aux définitions de méthodes de classe.

Comme pour les méthodes de classe, vous pouvez appeler une méthode de module en plaçant le nom du module et un point avant le nom de la méthode, et vous pouvez référencer une constante en utilisant le nom du module et deux deux-points.

Exemple

#!/usr/bin/ruby #Module défini dans le fichier trig.rb module Trig PI = 3.141592654 def Trig.sin(x) # .. end def Trig.cos(x) # .. end end

Nous pouvons définir plusieurs modules avec les mêmes noms de fonctions mais des fonctionnalités différentes :

Exemple

#!/usr/bin/ruby #Module défini dans le fichier moral.rb module Moral VERY_BAD = 0 BAD = 1 def Moral.sin(badness) # ... end end

Tout 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, puis le nom de la méthode.

Ruby requireInstruction

L'instruction require est similaire à l'instruction include en C et C++ et à l'instruction import en Java. Si un programme tiers veut utiliser un module défini, il peut simplement utiliser l'instruction Rubyrequirepour charger le fichier module :

Syntaxe

Syntaxe

require filename

Ici, l'extension de fichier.rbn'est pas requise.

Exemple

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

Ici, nous utilisons$LOAD_PATH << '.'pour indiquer à Ruby qu'il doit chercher dans le répertoire courant le fichier référencé. Si vous ne voulez pas utiliser $LOAD_PATH, vous pouvez utiliserrequire_relativepour référencer un fichier à partir d'un répertoire relatif.

Remarque :Ici, les fichiers contiennent les mêmes noms de fonctions. Donc, cela provoquerait une ambiguïté de code lors du référencement du programme appelant, mais les modules évitent cette ambiguïté, et nous pouvons utiliser le nom du module pour appeler la fonction appropriée.

Ruby includeInstruction

Vous pouvez intégrer des modules dans une classe. Pour intégrer un module dans une classe, vous pouvez utiliser l'instructioninclude:

Syntaxe

include modulename

Si le module est défini dans un fichier séparé, vous devez utiliser l'instructionrequirepour référencer le fichier avant d'intégrer le module.

Exemple

Supposons que le module suivant soit écrit dans le fichiersupport.rb.

module Week FIRST_DAY = "Sunday" def Week.weeks_in_month puts "Vous avez quatre semaines dans un mois" end def Week.weeks_in_year puts "Vous avez 52 semaines dans une année" end end

Maintenant, vous pouvez référencer le module dans une classe comme suit :

Exemple

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

Cela produira le résultat suivant :

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

Mixins en Ruby

Avant de lire cette section, vous devez avoir une compréhension de base des concepts orientés objet.

Lorsqu'une classe peut hériter des caractéristiques de plus d'une classe parente, on dit que la classe présente un héritage multiple.

Ruby ne prend pas directement en charge l'héritage multiple, mais les modules de Ruby ont une autre fonctionnalité magique. Elle élimine presque le besoin d'héritage multiple, en fournissant un mécanisme demixin.

Ruby n'implémente pas réellement l'héritage multiple, mais adopte plutôt une technique appelée mixin comme substitut. Lorsqu'un module est inclus dans une définition de classe, les méthodes du module sont intégrées à la classe.

Regardons l'exemple de code suivant pour en savoir plus sur les mixins :

Exemple

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
  • Le module A est composé des méthodes a1 et a2.
  • Le module B est composé des méthodes b1 et b2.
  • La classe Sample inclut les modules A et B.
  • La classe Sample peut accéder aux quatre méthodes, à savoir a1, a2, b1 et b2.
    • Par conséquent, vous pouvez voir que la classe Sample hérite de deux modules. Vous pouvez dire que la classe Sample utilise l'héritage multiple ou mixin 。

d'autres extensions.