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

Formulation + ortho + <source>
(→‎Méthodes de l'instance : clarifie l'exemple)
(Formulation + ortho + <source>)
 
== initialize ==
La méthode <tt>initialize</tt>, par exemple, est la méthode appelléeappelée lorsqu'une instance est créecréée via la méthode <tt>new</tt> :
 
<source lang="ruby">
class Point
class Point
def initialize ( x, y )
def initialize ( @x, =y x)
@yx = yx
end @y = y
end
def coords
def coords
puts "x : #{@x}"
puts "yx : #{@yx}"
puts "y : #{@y}"
end
end
end
</source>
 
Ici la méthode <tt>initialize</tt> définie les variable d'instances @x et @y en fonction des paramètres passés à la fonction <tt>new</tt>.
 
Si par exemple on initialise cetteun classeobjet comme suit :
<source lang="ruby">
p = Point.new(2,3)
p = Point.new(2,3)
 
# -> @x = 2 et @y = 3
</source>
 
== Valeurs par défaut ==
On peut en Ruby donner des valeurs par défaut aux arguments des méthodes.
<source lang="ruby">
class Parle
class Parle
def initialize ( nom = "vous" )
def initialize ( @quinom = nom"vous" )
end @qui = nom
end
def bonjour
def bonjour
puts "Bonjour #{@qui}"
puts "Bonjour #{@qui}"
end
end
end
</source>
 
Si l'on créeappelle la méthode sans argument, la valeur par defautdéfaut est assigné à la variable d'instance <tt>@qui</tt>
<source lang="ruby">
dit = Parle.new
dit = Parle.new
dit.bonjour
dit.bonjour
=> Bonjour vous
# => Bonjour vous
Si l'on crée la méthode avec un argument, celui-ci remplacera la valeur par défaut :
</source>
dit2 = Parle.new("Roger")
 
dit2.bonjour
Si l'on appelle la méthode avec un argument, celui-ci remplacera la valeur par défaut :
=> Bonjour Roger
<source lang="ruby">
dit2 = Parle.new("Roger")
dit2.bonjour
# => Bonjour Roger
</source>
 
== Méthodes de l'instance ==
La méthode générique, présente dans toutes les classeclasses, ''<tt>instance_methods''</tt> renvoie la liste des méthodes existantes.
<source lang="ruby">
Parle.instance_methodes
Parle.instance_methodes
=> ["bonjour", "method", "instance_variables", "__id__", "to_s", "send", "object_id", "dup", "private_methods",
"# =~> ["bonjour", "is_a?method", "classinstance_variables", "tainted?__id__", "singleton_methodsto_s", "eql?send", "untaintobject_id", "instance_of?dup", "idprivate_methods",
# "instance_variable_get=~", "inspectis_a?", "instance_evalclass", "tainted?", "extendsingleton_methods", "nileql?", "__send__untaint", "frozeninstance_of?", "taintid",
# "instance_variable_defined?instance_variable_get", "public_methodsinspect", "hashinstance_eval", "to_aextend", "clonenil?", "protected_methods__send__", "respond_tofrozen?", "taint",
# "instance_variable_defined?", "public_methods", "hash", "to_a", "clone", "protected_methods", "respond_to?",
"display", "freeze", "kind_of?", "==", "instance_variable_set", "type", "===", "equal?", "methods"]
# "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.
</source>
 
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"]
 
On peut obtenir une liste restreinte aux fonctions que l'on a crée en remplaçant l'argument <tt>true</tt> (vrai, valeur par défaut) par <tt>false</tt> (faux) :
Au contraire on peut obtenir les méthodes qui ne sont pas que des méthodes d'instances :
<source lang="ruby">
Parle.methods
Parle.instance_methods(false)
=> ["inspect", "private_class_method", "const_missing", "clone", "method", "public_methods",
# => ["bonjour"]
"public_instance_methods", "instance_variable_defined?", "method_defined?", "superclass", "equal?", "freeze",
</source>
"included_modules", "const_get", "methods", "respond_to?", "module_eval", "class_variables", "dup",
 
"protected_instance_methods", "instance_variables", "public_method_defined?", "__id__", "eql?", "object_id",
Au contraire, on peut obtenir les méthodes qui ne sont pas que des méthodes d'instances :
"const_set", "id", "singleton_methods", "send", "class_eval", "taint", "frozen?", "instance_variable_get",
<source lang="ruby">
"include?", "private_instance_methods", "__send__", "instance_of?", "private_method_defined?", "to_a", "name",
Parle.methods
"autoload", "type", "new", "<", "protected_methods", "instance_eval", "<=>", "display", "==", ">", "===",
# => ["inspect", "private_class_method", "const_missing", "clone", "method", "public_methods",
"instance_method", "instance_variable_set", "kind_of?", "extend", "protected_method_defined?", "const_defined?",
# "public_instance_methods", "instance_variable_defined?", "method_defined?", "superclass", "equal?", "freeze",
">=", "ancestors", "to_s", "<=", "public_class_method", "allocate", "hash", "class", "instance_methods",
"tainted?",# "=~included_modules", "private_methodsconst_get", "class_variable_defined?methods", "nilrespond_to?", "untaintmodule_eval", "constantsclass_variables", "is_a?dup",
# "protected_instance_methods", "instance_variables", "public_method_defined?", "__id__", "eql?", "object_id",
"autoload?"]
# "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?"]
</source>
 
=== Classe de l'instance ===
La methodeméthode <tt>type</tt> permet de connaitreconnaître le type, (donc la classe) utilisé par l'instance :
<source lang="ruby">
dit = Parle.new
dit.type
# => Parle
</source>
 
== Existence d'une méthode ==
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 :
<source lang="ruby">
Parle.method_defined?("bonjour")
Parle.method_defined?("bonjour")
=> true
# => true
Parle.method_defined?("aurevoir")
Parle.method_defined?("aurevoir")
=> false
# => false
On peut également determiner si elle est publique (accessible depuis l'exterieure de la classe) :
</source>
Parle.public_method_defined?("bonjour")
 
=> true
On peut également déterminer si elle est publique (accessible en dehors de la classe) :
<source lang="ruby">
Parle.public_method_defined?("bonjour")
# => true
</source>
 
[[Catégorie:Programmation Ruby (livre)]]