Ruby/Méthodes (fin)

**Méthodes (fin)**
Leçon : Ruby

Chapitre n^o 14
Chap. préc. :	Symboles

En raison de limitations techniques, la typographie souhaitable du titre, « Ruby : Méthodes (fin)
Ruby/Méthodes (fin) », n'a pu être restituée correctement ci-dessus.

Les alias de méthodes

Définition

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 :

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 :

Exemple

alias :denomme :nomme

Le résultat est le même si vous aviez défini une méthode denomme identique à la méthode nomme.

Propriété

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

Propriété

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 :

Exemple

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

Le mot-clé à placer pour déclarer des méthodes privées est private :

Exemple

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.

Propriété

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 :

Exemple

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

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 :

Exemple

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.

Propriété

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 :

Exemple

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

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.

Propriété

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

Définition

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 :

Exemple

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 :

Exemple

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`

Exemple

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 :

Exemple

attr_reader :prix, :puissance, :poids

`attr_writer`

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 :

Exemple

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`

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.

Exemple

class Ordinateur
  attr_accessor :prix
end

monOrdi.prix = 400
puts monOrdi.prix

Paramètres optionnels

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 :

Exemple

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 :

Exemple

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 :

Exemple

def hurle(*params)
  #
end

Tous les arguments seront placés dans le tableau params.

Conclusion

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.

Ruby

Symboles