Module Ruby (Module)

Un module ne peut être défini que par un autre module<🎜><🎜><🎜><🎜>

Syntaxe

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

Le nom des constantes de module est similaire au nom des constantes de classe, commençant par une lettre majuscule. Les définitions de méthodes se ressemblent également : les définitions de méthodes de module sont similaires aux définitions de méthodes de classe.

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

Instance

#!/usr/bin/ruby

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

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

On peut définir plusieurs modules avec le même nom de fonction mais des fonctions différentes :

#!/usr/bin/ruby

# 定义在 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 peut spécifier que le nom du module est suivi d'un point et que le point est suivi du nom de la méthode. Instruction

Ruby require L'instruction

require est similaire à l'instruction include en C et C++ et à l'instruction import en Java. Si un programme tiers souhaite utiliser l'un des modules définis, il peut simplement utiliser l'instruction Ruby require pour charger le fichier du module :

syntaxe

require filename

ici , l'extension de fichier .rb n'est pas obligatoire.

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 faire savoir à Ruby qu'il doit rechercher le fichier référencé dans le répertoire actuel. Si vous ne souhaitez pas utiliser $LOAD_PATH, vous pouvez utiliser require_relative pour référencer des fichiers à partir d'un répertoire relatif.

Remarque : Ici, les fichiers contiennent le même nom de fonction. Ainsi, cela conduit à une ambiguïté de code lors du référencement du programme appelant, mais les modules évitent cette ambiguïté de code et nous pouvons appeler la fonction appropriée en utilisant le nom du module.

Instruction Ruby include

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

Syntaxe

include modulename

Si le module est défini dans un fichier séparé, alors dans le module embed doit utiliser l'instruction require pour référencer le fichier.

Exemple

Supposons que le module suivant soit écrit dans le fichier 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

Vous pouvez maintenant référencer le module dans votre classe comme ceci :

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

Avant en lisant cette section, vous devez avoir une compréhension préliminaire des concepts orientés objet.

Lorsqu'une classe peut hériter des caractéristiques d'une classe de plusieurs classes parents, la classe affiche 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. Il élimine presque le besoin d'héritage multiple, en fournissant un périphérique appelé mixin.

Ruby n'implémente pas vraiment plusieurs mécanismes d'héritage, mais utilise la technologie mixin en remplacement. En incluant le module dans la définition de classe, les méthodes du module sont mélangées dans la classe.

Regardons l'exemple de code suivant pour comprendre le mixin en profondeur :

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 se compose des méthodes a1 et a2.

• Le module B comprend les méthodes b1 et b2.

• L'exemple de classe contient les modules A et B.

• Class Sample a accès aux quatre méthodes, à savoir a1, a2, b1 et b2.

Ainsi, 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 .