« Programmation Ruby/Méthodes » : différence entre les versions
m <source> -> <syntaxhighlight> (phab:T237267) |
|||
Ligne 15 : | Ligne 15 : | ||
Ils peuvent être fournis de façon unique ou en liste via : |
Ils peuvent être fournis de façon unique ou en liste via : |
||
< |
<syntaxhighlight lang="ruby"> |
||
def mamethode(param1, *reste) |
def mamethode(param1, *reste) |
||
"mon param1 : #{param1}" << "et le #{reste.join(', ')}" unless reste.empty? |
"mon param1 : #{param1}" << "et le #{reste.join(', ')}" unless reste.empty? |
||
Ligne 22 : | Ligne 22 : | ||
mamethode("toto", "titi") » "mon param1 : toto et titi" |
mamethode("toto", "titi") » "mon param1 : toto et titi" |
||
mamethode "toto", "titi", "tutu" » "mon param1 : toto et titi, tutu" |
mamethode "toto", "titi", "tutu" » "mon param1 : toto et titi, tutu" |
||
</syntaxhighlight> |
|||
</source> |
|||
=== Les blocs liés === |
=== Les blocs liés === |
||
Ligne 28 : | Ligne 28 : | ||
Une méthode Ruby peut recevoir en paramètre la référence à un bloc de code tel que : |
Une méthode Ruby peut recevoir en paramètre la référence à un bloc de code tel que : |
||
< |
<syntaxhighlight lang="ruby"> |
||
def donnezmoiducode(param) |
def donnezmoiducode(param) |
||
if block_given? |
if block_given? |
||
Ligne 38 : | Ligne 38 : | ||
donnezmoiducode("j'ai faim !") » "j'ai faim !" |
donnezmoiducode("j'ai faim !") » "j'ai faim !" |
||
donnezmoiducode("J'ai faim !") { |s| s = "miam !"') } # => "miam !" |
donnezmoiducode("J'ai faim !") { |s| s = "miam !"') } # => "miam !" |
||
</syntaxhighlight> |
|||
</source> |
|||
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 cet objet entre dans la liste de paramètres de la méthode : |
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 cet objet entre dans la liste de paramètres de la méthode : |
||
< |
<syntaxhighlight lang="ruby"> |
||
class BoiteACalculs |
class BoiteACalculs |
||
def initialize(nom, &bloc) |
def initialize(nom, &bloc) |
||
Ligne 54 : | Ligne 54 : | ||
calcul. application(10) #=> "10 Fois deux = 20" |
calcul. application(10) #=> "10 Fois deux = 20" |
||
calcul. application(20) #=> "20 Fois deux = 40" |
calcul. application(20) #=> "20 Fois deux = 40" |
||
</syntaxhighlight> |
|||
</source> |
|||
== le constructeur initialize == |
== le constructeur initialize == |
||
Ligne 60 : | Ligne 60 : | ||
La méthode <code>initialize</code>, par exemple, est la méthode appelée lorsqu'une instance est créée via la méthode <code>new</code> : |
La méthode <code>initialize</code>, par exemple, est la méthode appelée lorsqu'une instance est créée via la méthode <code>new</code> : |
||
< |
<syntaxhighlight lang="ruby"> |
||
class Point |
class Point |
||
def initialize ( x, y ) |
def initialize ( x, y ) |
||
Ligne 71 : | Ligne 71 : | ||
end |
end |
||
end |
end |
||
</syntaxhighlight> |
|||
</source> |
|||
Ici la méthode <code>initialize</code> définie les variable d'instances @x et @y en fonction des paramètres passés à la fonction <code>new</code>. |
Ici la méthode <code>initialize</code> définie les variable d'instances @x et @y en fonction des paramètres passés à la fonction <code>new</code>. |
||
Si par exemple on initialise un objet comme suit : |
Si par exemple on initialise un objet comme suit : |
||
< |
<syntaxhighlight lang="ruby"> |
||
p = Point.new(2,3) |
p = Point.new(2,3) |
||
# -> @x = 2 et @y = 3 |
# -> @x = 2 et @y = 3 |
||
</syntaxhighlight> |
|||
</source> |
|||
== Valeurs par défaut == |
== Valeurs par défaut == |
||
On peut en Ruby donner des valeurs par défaut aux arguments des méthodes. |
On peut en Ruby donner des valeurs par défaut aux arguments des méthodes. |
||
< |
<syntaxhighlight lang="ruby"> |
||
class Parle |
class Parle |
||
def initialize ( nom = "vous" ) |
def initialize ( nom = "vous" ) |
||
Ligne 92 : | Ligne 92 : | ||
end |
end |
||
end |
end |
||
</syntaxhighlight> |
|||
</source> |
|||
Si l'on appelle la méthode sans argument, la valeur par défaut est assigné à la variable d'instance <code>@qui</code> |
Si l'on appelle la méthode sans argument, la valeur par défaut est assigné à la variable d'instance <code>@qui</code> |
||
< |
<syntaxhighlight lang="ruby"> |
||
dit = Parle.new |
dit = Parle.new |
||
dit.bonjour |
dit.bonjour |
||
# => Bonjour vous |
# => Bonjour vous |
||
</syntaxhighlight> |
|||
</source> |
|||
Si l'on appelle la méthode avec un argument, celui-ci remplacera la valeur par défaut : |
Si l'on appelle la méthode avec un argument, celui-ci remplacera la valeur par défaut : |
||
< |
<syntaxhighlight lang="ruby"> |
||
dit2 = Parle.new("Roger") |
dit2 = Parle.new("Roger") |
||
dit2.bonjour |
dit2.bonjour |
||
# => Bonjour Roger |
# => Bonjour Roger |
||
</syntaxhighlight> |
|||
</source> |
Version actuelle du 16 avril 2020 à 08:33
En programmation objet, les méthodes sont les fonctions appartenant à une classe. En réalité, elles sont des messages envoyé à un objet.
En Ruby, elles sont définies de la façon suivante :
def <nom de la méthode> (*arguments,&bloc) <bloc de code de la méthode> end
Les arguments[modifier | modifier le wikicode]
Les arguments de la méthode forment une liste de références d'objets.
Ils peuvent être fournis de façon unique ou en liste via :
def mamethode(param1, *reste)
"mon param1 : #{param1}" << "et le #{reste.join(', ')}" unless reste.empty?
end
mamethode("toto") » "mon param1 : toto"
mamethode("toto", "titi") » "mon param1 : toto et titi"
mamethode "toto", "titi", "tutu" » "mon param1 : toto et titi, tutu"
Les blocs liés[modifier | modifier le wikicode]
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 cet objet entre dans la liste de paramètres 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"
le constructeur initialize[modifier | modifier le wikicode]
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
Valeurs par défaut[modifier | modifier le wikicode]
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