Les méthodes Ruby sont définies avec def...end. Ruby offre une gestion flexible et expressive des arguments — valeurs par défaut, arguments nommés, splat (*) pour les arguments variables, et blocs — avec la convention que la dernière expression est la valeur de retour implicite.
def add(a, b)
a + b # NO `return` needed — the last expression is returned implicitly
end
add(2, 3) # 5
def greet(name)
"Hello, #{name}" # implicitly returned
end
Les méthodes Ruby retournent automatiquement la dernière expression évaluée — vous écrivez rarement return (utilisé seulement pour les retours anticipés). C'est idiomatique.
# default arguments
def greet(name, greeting = "Hello")
"#{greeting}, #{name}"
end
greet("Ann") # "Hello, Ann"
greet("Ann", "Hi") # "Hi, Ann"
# KEYWORD arguments (clearer, order-independent) — common in modern Ruby
def create_user(name:, age: 0, role: :user)
# name is required (no default); age/role optional
end
create_user(name: "Ann", role: :admin) # pass by keyword — readable
Les arguments nommés (name:) sont idiomatiques dans le Ruby moderne — ils rendent les appels auto-documentés et indépendants de l'ordre.
def sum(*numbers) # * collects extra positional args into an array
numbers.sum
end
sum(1, 2, 3, 4) # 10
def config(**options) # ** collects keyword args into a hash
options[:timeout]
end
config(timeout: 30, retries: 3)
*args collecte un nombre variable d'arguments positionnels dans un tableau ; **options collecte les arguments nommés dans un hash.
def valid?(x) # ? convention → returns a boolean (predicate method)
x > 0
end
def process!(data) # ! convention → modifies in place / is "dangerous"
data.map!(&:upcase)
end
Conventions de nommage : les méthodes se terminant par ? retournent des booléens (prédicats), et ! indique une version destructive/en place ou "dangereuse".
Les méthodes sont les blocs de construction du comportement en Ruby, et comprendre la gestion flexible et expressive des arguments de Ruby ainsi que ses conventions est une connaissance importante au quotidien.
Plusieurs aspects sont distinctement Ruby et méritent d'être connus : le retour implicite (les méthodes retournent la dernière expression évaluée, donc return est rarement écrit — le Ruby idiomatique repose sur ceci), les arguments nommés (name: — la façon moderne et idiomatique d'écrire des appels clairs, auto-documentés et indépendants de l'ordre), et les arguments splat (*args/**options pour un nombre variable d'arguments).
Tout aussi important sont les conventions de nommage — les méthodes se terminant par ? sont des prédicats retournant des booléens (valid?, empty?), et les méthodes se terminant par ! sont des versions destructives/en place ou "dangereuses" (map!, sort!) — qui sont omniprésentes en Ruby et Rails et communiquent le comportement d'une méthode en un coup d'œil (savoir que ! signifie généralement "modifie sur place" est important pour éviter les mutations involontaires).
Comprendre comment définir des méthodes avec les arguments flexibles de Ruby (par défaut, nommés, splats), l'idiome de retour implicite, et les conventions de nommage ?/! est fondamental pour écrire et lire du Ruby idiomatique — ces fonctionnalités et conventions apparaissent constamment, et les maîtriser (en particulier les arguments nommés pour les API claires et les conventions ?/! pour comprendre le comportement des méthodes) est une connaissance essentielle et fréquemment appliquée pour un développement Ruby efficace.