« Programmation Ruby/Méthodes » : différence entre les versions

Un livre de Wikilivres.
Contenu supprimé Contenu ajouté
→‎Méthodes de l'instance : clarifie l'exemple
Ligne 83 : Ligne 83 :
La methode type permet de connaitre le type, donc la classe utilisé par l'instance :
La methode type permet de connaitre le type, donc la classe utilisé par l'instance :


dit = Parle.new
parle.type
dit.type
=> Parle
=> Parle


== Existance d'une méthode ==
== Existance d'une méthode ==

Version du 26 décembre 2007 à 16:38

<< Retour au sommaire << Retour à programmation objet

En programmation objet, les méthodes sont les fonctions appartenant à une classe.

En Ruby, elle sont définies de la façon suivante :

def <nom de la méthode> (<arguments>)
  <bloc de code de la méthode>
end

Plusieurs méthodes sont prédéfinies dans toutes les classes.

initialize

La méthode initialize par exemple est la méthode appellé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 cette classe comme suit :

p = Point.new(2,3)

@x = 2 et @y = 3

Valeurs par défaut

On peut en Ruby donner des valeurs par défaut aux méthodes.

class Parle
  def initialize ( nom = "vous" )
    @qui = nom
  end
  def bonjour
    puts "Bonjour #{@qui}"
  end
end

Si l'on crée la méthode sans argument, la valeur par defaut est assigné à la variable d'instance @qui

dit = Parle.new
dit.bonjour
                    => Bonjour vous

Si l'on crée la méthode avec un argument, celui-ci remplacera la valeur par défaut :

dit2 = Parle.new("Roger")
dit2.bonjour
                    => Bonjour Roger

Méthodes de l'instance

La méthode générique, présente dans toutes les classe, 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 réstreintes au fonctions que l'on a crée en remplacant le true (vrai, valeur par défaut) par un 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?"]

Classe de l'instance

La methode type permet de connaitre le type, donc la classe utilisé par l'instance :

 dit = Parle.new
 dit.type
       => Parle

Existance 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 determiner si elle est publique (accessible depuis l'exterieure de la classe) :

Parle.public_method_defined?("bonjour")
=> true