Programmation Ruby/Méthodes
Un livre de Wikibooks.
<< Retour au sommaire << Retour à programmation objet
En programmation objet, les méthodes sont les fonctions appartenant à une classe. En réalité, elles sont des messages envoyé à un objet.
En Ruby, elle sont définies de la façon suivante :
def <nom de la méthode> (*arguments,&bloc) <bloc de code de la méthode> end
Sections |
[modifier] Les arguments
Les arguments de de la méthodes forme une liste de référence d'objets.
Ils peuvent êtres fournit de façon unique ou en liste via :
def mamethode(param1, *reste) "mon param1 : #{arg1}" << "et le #{rest.join(', ')}" unless rest.empty? end mamethode("toto") » "mon param1 : toto" mamethode("toto", "titi") » "mon param1 : toto et tutu" mamethode "toto", "titi", "tutu" » "mon param1 : toto et titi, tutu"
[modifier] Les blocs liés
Une méthode Ruby peut recevoir en paramètre la référence à un bloc de code tel que :
def donnezmoiducode(param) if block_given? yield(param) else param end end donnezmoiducode("j'ai faim !") » "j'ai faim !" donnezmoiducode("J'ai faim !") { |s| s = "miam !"') } # => "miam !"
Si en dernier paramètre de méthode, en prototype, on trouve une déclaration explicite avec une esperluette, alors le bloc est converti en objet Proc et cette objet entre dans la liste de paramètre de la méthode :
class BoiteACalculs def initialize(nom, &bloc) @nom, @bloc = nom, bloc end def application(valeur) "#{valeur} #{@nom} = #{ @bloc.call(valeur) }" end end calcul = BoiteACalculs.new("Fois deux ") { |val| val * 2 } calcul. application(10) #=> "10 Fois deux = 20" calcul. application(20) #=> "20 Fois deux = 40"
[modifier] le constructeur initialize
La méthode initialize, par exemple, est la méthode appelée lorsqu'une instance est créée via la méthode new :
class Point def initialize ( x, y ) @x = x @y = y end def coords puts "x : #{@x}" puts "y : #{@y}" end end
Ici la méthode initialize définie les variable d'instances @x et @y en fonction des paramètres passés à la fonction new.
Si par exemple on initialise un objet comme suit :
p = Point.new(2,3) # -> @x = 2 et @y = 3
[modifier] Valeurs par défaut
On peut en Ruby donner des valeurs par défaut aux arguments des méthodes.
class Parle def initialize ( nom = "vous" ) @qui = nom end def bonjour puts "Bonjour #{@qui}" end end
Si l'on appelle la méthode sans argument, la valeur par défaut est assigné à la variable d'instance @qui
dit = Parle.new dit.bonjour # => Bonjour vous
Si l'on appelle la méthode avec un argument, celui-ci remplacera la valeur par défaut :
dit2 = Parle.new("Roger") dit2.bonjour # => Bonjour Roger
[modifier] Méthodes de l'instance
La méthode générique, présente dans toutes les classes, instance_methods renvoie la liste des méthodes existantes.
Parle.instance_methodes # => ["bonjour", "method", "instance_variables", "__id__", "to_s", "send", "object_id", "dup", "private_methods", # "=~", "is_a?", "class", "tainted?", "singleton_methods", "eql?", "untaint", "instance_of?", "id", # "instance_variable_get", "inspect", "instance_eval", "extend", "nil?", "__send__", "frozen?", "taint", # "instance_variable_defined?", "public_methods", "hash", "to_a", "clone", "protected_methods", "respond_to?", # "display", "freeze", "kind_of?", "==", "instance_variable_set", "type", "===", "equal?", "methods"]
Cette liste contient l'ensemble des méthodes existant par défaut, plus celle qui ont été créées.
On peut obtenir une liste restreinte aux fonctions que l'on a crée en remplaçant l'argument true (vrai, valeur par défaut) par false (faux) :
Parle.instance_methods(false) # => ["bonjour"]
Au contraire, on peut obtenir les méthodes qui ne sont pas que des méthodes d'instances :
Parle.methods # => ["inspect", "private_class_method", "const_missing", "clone", "method", "public_methods", # "public_instance_methods", "instance_variable_defined?", "method_defined?", "superclass", "equal?", "freeze", # "included_modules", "const_get", "methods", "respond_to?", "module_eval", "class_variables", "dup", # "protected_instance_methods", "instance_variables", "public_method_defined?", "__id__", "eql?", "object_id", # "const_set", "id", "singleton_methods", "send", "class_eval", "taint", "frozen?", "instance_variable_get", # "include?", "private_instance_methods", "__send__", "instance_of?", "private_method_defined?", "to_a", "name", # "autoload", "type", "new", "<", "protected_methods", "instance_eval", "<=>", "display", "==", ">", "===", # "instance_method", "instance_variable_set", "kind_of?", "extend", "protected_method_defined?", "const_defined?", # ">=", "ancestors", "to_s", "<=", "public_class_method", "allocate", "hash", "class", "instance_methods", # "tainted?", "=~", "private_methods", "class_variable_defined?", "nil?", "untaint", "constants", "is_a?", # "autoload?"]
[modifier] Classe de l'instance
La méthode type permet de connaître le type (donc la classe) utilisé par l'instance :
dit = Parle.new dit.type # => Parle
[modifier] Existence d'une méthode
On peut déterminer si une méthode existe ou pas à l'aide des méthodes par défaut :
Parle.method_defined?("bonjour") # => true Parle.method_defined?("aurevoir") # => false
On peut également déterminer si elle est publique (accessible en dehors de la classe) :
Parle.public_method_defined?("bonjour") # => true
