I metodi Ruby sono definiti con def...end. Ruby ha un'handling degli argomenti flessibile ed espressivo — valori predefiniti, argomenti con parola chiave, splat (*) per argomenti variabili, e blocchi — più la convenzione che l'ultima espressione è il valore di ritorno implicito.
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
I metodi Ruby ritornano automaticamente l'ultima espressione valutata — raramente si scrive return (viene usato solo per ritorni anticipati). Questo è idiomatico.
# 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
Gli argomenti con parola chiave (name:) sono idiomatici nel Ruby moderno — rendono le chiamate auto-documentate e indipendenti dall'ordine.
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 raccoglie argomenti posizionali variabili in un array; **options raccoglie argomenti con parola chiave in 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
Convenzioni di denominazione: i metodi che terminano in ? ritornano booleani (predicati), e ! indica una versione distruttiva/in-place o "pericolosa".
I metodi sono i blocchi costruttivi del comportamento in Ruby, e comprendere l'handling degli argomenti flessibile ed espressivo di Ruby e le sue convenzioni è una conoscenza importante nel lavoro quotidiano.
Vari aspetti sono distintivamente Ruby e meritano di essere conosciuti: il ritorno implicito (i metodi ritornano l'ultima espressione valutata, quindi return è raramente scritto — Ruby idiomatico si basa su questo), gli argomenti con parola chiave (name: — il modo moderno e idiomatico per scrivere chiamate chiare, auto-documentate e indipendenti dall'ordine), e gli argomenti splat (*args/**options per numeri variabili di argomenti).
Equalmente importanti sono le convenzioni di denominazione — i metodi che terminano in ? sono predicati che ritornano booleani (valid?, empty?), e i metodi che terminano in ! sono versioni distruttive/in-place o "pericolose" (map!, sort!) — che sono pervasive in Ruby e Rails e comunicano il comportamento di un metodo a colpo d'occhio (sapere che ! tipicamente significa "modifica in place" è importante per evitare mutazioni indesiderate).
Comprendere come definire i metodi con gli argomenti flessibili di Ruby (predefiniti, con parola chiave, splat), l'idioma del ritorno implicito, e le convenzioni di denominazione ?/! è fondamentale per scrivere e leggere Ruby idiomatico — queste caratteristiche e convenzioni appaiono costantemente, e comprenderle (specialmente gli argomenti con parola chiave per API pulite e le convenzioni ?/! per comprendere il comportamento dei metodi) è una conoscenza essenziale e frequentemente applicata per lo sviluppo Ruby efficace.