Metodele Ruby sunt definite cu def...end. Ruby are o gestionare flexibilă și expresivă a argumentelor — valori implicite, argumente cu cuvinte cheie, splat (*) pentru argumente variabile și blocuri — plus convenția că ultima expresie evaluată este valoarea de retur implicită.
()
a + b
add(, )
()
Metodele Ruby returnează ultima expresie evaluată automat — rareori scrieți return (se folosește doar pentru returnări anticipate). Aceasta este idiomatic.
# 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
Argumentele cu cuvinte cheie (name:) sunt idiomatic în Ruby modern — fac apelurile autodocumentate și independente de 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 colectează argumente poziționale variabile într-un array; **options colectează argumente cu cuvinte cheie într-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
Convenții de denumire: metodele care se termină în ? returnează booleeni (predicate), iar ! indică o versiune distructivă/pe loc sau "periculoasă".
Metodele sunt elementele de bază ale comportamentului în Ruby, iar înțelegerea gestionării flexibile și expresive a argumentelor și convenții Ruby este cunoștință importantă pentru fiecare zi.
Citeva aspecte sunt distinct Ruby și merită cunoscute: returnul implicit (metodele returnează ultima expresie evaluată, deci return rareori se scrie — Ruby idiomatic se bazează pe aceasta), argumentele cu cuvinte cheie (name: — modul modern și idiomatic de a scrie apeluri clare, autodocumentate, independente de ordine) și argumentele splat (*args/**options pentru numere variabile de argumente).
Egal de importante sunt convenții de denumire — metodele care se termină în ? sunt predicate returnând booleeni (valid?, empty?), iar metodele care se termină în ! sunt versiuni distructive/pe loc sau "periculoase" (map!, sort!) — care sunt omniprezente în Ruby și Rails și comunică comportamentul unei metode dintr-o privire (știind că ! de obicei înseamnă "modifică pe loc" este important pentru a evita mutații neintenționate).
Înțelegerea cum să definești metode cu argumentele flexibile ale Ruby (valori implicite, cuvinte cheie, splat-uri), idiomul de retur implicit și convenții de denumire ?/! este fundamental pentru a scrie și citi Ruby idiomatic — aceste caracteristici și convenții apar constant, și a le înțelege (mai ales argumentele cu cuvinte cheie pentru API-uri curate și convenții ?/! pentru înțelegerea comportamentului metodei) este cunoștință esențială, frecvent aplicată pentru dezvoltare Ruby eficientă.