Ruby/Méthodes (fin)
Les alias de méthodes
[modifier | modifier le wikicode]
Créer un alias d'une méthode vous permet de créer une copie conforme de cette méthode : vous obtenez une nouvelle méthode fonctionnant de manière strictement identique à la première, disponible sous un nouveau nom.
L'intérêt est de disposer de plusieurs noms pour une seule méthode, ou encore de conserver l'ancienne méthode (afin de pouvoir éventuellement la rappeler) avant de la redéfinir.
Cette opération se fait le plus simplement du monde à l'aide du mot-clé alias suivi du nom de la méthode à créer et du nom de la méthode originelle, comme l'illustre cet exemple :
def nomme(nom)
puts nom
end
alias denomme nomme
Nous venons de créer un alias denomme pour la méthode nomme. Au lieu de passer les noms des méthodes en question, nous pouvons tout aussi bien passer les symboles s'y rapportant :
alias :denomme :nomme
Le résultat est le même si vous aviez défini une méthode denomme identique à la méthode nomme.
alias doit être suivi de deux méthodes, ni plus, ni moins (la copie en premier, l'originale en second).
Redéfinir une de ces deux méthodes n'altérera pas l'autre.
Méthodes privées et protégées
[modifier | modifier le wikicode]Tout d’abord, par défaut, les méthodes sont dites publiques, c'est-à-dire qu’elles sont accessibles à l'intérieur comme à l'extérieur de la classe, de même que par les sous-classes de la classe en question. Elles sont donc utilisables partout.
En plaçant le mot-clé public au sein de la classe, toutes les méthodes déclarées après seront publiques. Ce mot est optionnel, et toutes les méthodes déclarées au début de la classe seront publiques jusqu'à ce qu'on place un autre mot-clé pour modifier l'accès :
class Machine
public # optionnel
def run
puts "je suis une machine"
end
end
monOrdi = Machine.new
monOrdi.run
Nous voyons ici que run est accessible depuis l'extérieur de la classe. Pour éviter cela, nous pouvons réglementer l'accès à certaines méthodes en les rendant privées ou protégées.
Les méthodes privées
[modifier | modifier le wikicode]Le mot-clé à placer pour déclarer des méthodes privées est private :
class Machine
def run
print "machine"
end
private
def run_private
print " privee"
end
end
Toutes les méthodes déclarées après le mot-clé private sont privées, jusqu'à (éventuellement) un autre changement d'accès.
Les méthodes privées ne sont accessibles qu’à l'intérieur de la classe elle-même et de ses sous-classes, pas à l'extérieur !
Ainsi, en considérant la classe définie plus haut :
monOrdi = Machine.new
monOrdi.run # correct
monOrdi.run_private # erreur
En appelant la méthode privée run_private depuis l'extérieur de la classe, on obtient une erreur. En revanche, cette méthode peut être appelée depuis une méthode publique (run par exemple).
Les méthodes protégées
[modifier | modifier le wikicode]Le fonctionnement des méthodes protégées est (quasiment) le même que celui des méthodes privées. Le mot-clé changeant l'accès de ces méthodes est protected :
class Machine
def run
print "machine"
run_protect
end
protected
def run_protect
print " protegee"
end
end
Les méthodes protégées sont accessibles depuis la classe et ses sous-classes, mais pas depuis l'extérieur. Ainsi, l'appel de run_protect depuis l'extérieur de la classe provoque une erreur, mais l'appel à run (elle-même appelant run_protect) est correct.
Un objet peut accéder aux méthodes protégées d'un autre objet du même type, mais pas aux méthodes privées.
Considérons cette classe :
class Machine
def run(autre)
print "je suis une machine"
autre.run_protect
autre.run_private # => erreur
end
private
def run_private
print " privee"
end
protected
def run_protect
print " protegee"
end
end
monOrdi = Machine.new
tonOrdi = Machine.new
monOrdi.run(tonOrdi)
Autres précisions
[modifier | modifier le wikicode]Si vous voulez que des méthodes déclarées après d'autres méthodes privées ou protégées soient publiques, vous devez (re)placer le mot-clé public avant leur déclaration.
Vous pouvez placer autant de méthodes que vous le souhaitez après chacun de ces mots-clés, vous ne devez pas le remettre avant chaque méthode comme dans d'autres langages.
Les accesseurs
[modifier | modifier le wikicode]Les accesseurs sont des méthodes particulières qui vous permettent d'accéder aux variables d'instance de votre objet pour les lire ou les modifier.
Vous pouvez bien entendu les écrire vous-mêmes, par exemple pour une classe Ordinateur ayant une variable d'instance @prix :
class Ordinateur
def prix=(arg)
@prix = arg
end
def prix
@prix
end
end
monOrdi = Ordinateur.new
Il nous suffit d'appeler la méthode prix= sur l’objet monOrdi afin de modifier la variable @prix, et un appel à prix retourne la valeur de cette variable d'instance :
monOrdi.prix = 400
puts monOrdi.prix
La première méthode est une méthode d'écriture (ou setter) puisqu'on modifie la variable, tandis que la seconde est une méthode de lecture (ou getter) puisqu'on ne s'intéresse qu’à la valeur actuelle de la variable en question.
Il peut être long (et fastidieux) de définir ces méthodes pour chacune de nos variables d'instance, aussi Ruby peut s'en charger à notre place.
attr_reader
[modifier | modifier le wikicode]class Ordinateur
attr_reader :prix
end
Nous passons le symbole :prix à la méthode attr_reader (Module#attr_reader). Cela a pour effet de créer la méthode de lecture pour cette variable. Nous pouvons donc utiliser monOrdi.prix comme si nous l'avions défini nous-mêmes.
Pour définir plusieurs de ces méthodes en une seule fois, il suffit de passer tous les symboles (correspondants aux variables d'instance) à la méthode attr_reader :
attr_reader :prix, :puissance, :poids
attr_writer
[modifier | modifier le wikicode]Pour disposer de la méthode d'écriture, le principe est le même : Ruby met à notre disposition une méthode attr_writer à laquelle nous passons les symboles correspondant aux variables d'instance :
class Ordinateur
attr_writer :prix
end
Ceci nous permet d’utiliser monOrdi.prix= comme si nous l'avions défini nous-mêmes.
attr_accessor
[modifier | modifier le wikicode]Une dernière méthode, attr_accessor (Module#attr_accessor), fonctionnant de la même manière que les deux précédentes, permet de déclarer en une seule fois les méthodes de lecture et d'écriture pour chaque variable passée en paramètre.
class Ordinateur
attr_accessor :prix
end
monOrdi.prix = 400
puts monOrdi.prix
Paramètres optionnels
[modifier | modifier le wikicode]Lors de la déclaration d'une méthode, vous pouvez préciser si certains paramètres sont optionnels ; il est alors possible de leur assigner une valeur par défaut . Mais il est également possible d'envoyer des paramètres supplémentaires à une méthode, ils seront alors rangés dans un tableau. Voyons comment procéder :
def hurle(intonation, langue="fr", *duree)
#
end
À travers cet exemple, nous voyons que le paramètre intonation est obligatoire, que le paramètre langue ne l'est pas : si aucune valeur n'est précisée, sa valeur par défaut sera "fr". La méthode rangera tous les arguments supplémentaires qu'elle recevra dans un tableau nommé duree.
Ainsi, voici quelques possibilités pour appeler cette méthode :
hurle "fort"
hurle "lala", "en"
hurle "tres fort", "jap", 5, 6, 9, 27
Dans le dernier exemple, le tableau duree sera tel que : duree = [5, 6, 9, 27].
Pour que notre méthode puisse recevoir un nombre quelconque de paramètres, il nous suffit de la déclarer ainsi :
def hurle(*params)
#
end
Tous les arguments seront placés dans le tableau params.
Conclusion
[modifier | modifier le wikicode]Ce que nous venons de voir dans ce chapitre permet d’utiliser l'encapsulation (définie dans un chapitre précédent) : nous définissons des accesseurs (en lecture) publics pour les variables de nos instances et nous masquons le reste (en écriture) à l'utilisateur de la classe.
