A Ruby metódusok a def...end szintaxissal definiálódnak. A Ruby rugalmas és kifejező argumentumkezeléssel rendelkezik — alapértelmezett értékek, kulcsszavas argumentumok, splat (*) a változó számú argumentumokhoz, és blokkok — valamint az a konvenció, hogy az utolsó kifejezés az implicit visszatérési érték.
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
A Ruby metódusok automatikusan az utolsó kiértékelt kifejezést adják vissza — ritkán írunk return utasítást (csak a korai visszatérésekhez használatos). Ez idiomatikus.
# 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
A kulcsszavas argumentumok (name:) az idiomatikus modern Ruby — öndokumentáló hívásokat eredményeznek és sorrendtől függetlenek.
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)
A *args a pozicionális argumentumokat egy tömbben gyűjti össze; a **options a kulcsszavas argumentumokat egy hash-ben gyűjti össze.
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
Elnevezési konvenciók: a ?-vel végződő metódusok logikai értékeket adnak vissza (predikátumok), a ! pedig egy destruktív/helyben vagy "veszélyes" verziót jelöl.
A metódusok a Ruby viselkedésének építőkövei, és a Ruby rugalmas, kifejező argumentumkezelésének és konvencióinak megértése fontos mindennapi ismeret.
Néhány szempont egyedileg Ruby-specifikus és érdemes ismerni: az implicit return (a metódusok az utolsó kiértékelt kifejezést adják vissza, így a return ritkán írható — az idiomatikus Ruby erre támaszkodik), a kulcsszavas argumentumok (name: — a modern, idiomatikus módja az egyértelmű, öndokumentáló, sorrendtől független metódushívások írásának), valamint a splat argumentumok (*args/**options a változó számú argumentumokhoz).
Equallyként fontos a elnevezési konvenciók — a ?-vel végződő metódusok predikátumok, amelyek logikai értékeket adnak vissza (valid?, empty?), a !-vel végződő metódusok pedig destruktívak/helyben történnek vagy "veszélyesek" (map!, sort!) — amelyek a Ruby-ban és Rails-ben széles körben elterjedtek, és egy metódus viselkedését első pillantásra kommunikálják (fontos tudni, hogy a ! általában azt jelenti, hogy "helyben módosít" az értékelések elkerülése érdekében).
Annak megértése, hogy hogyan kell metódusokat definiálni Ruby rugalmas argumentumaival (alapértelmezett értékek, kulcsszavak, splats), az implicit-return idiómával, és a ?/! elnevezési konvenciókkal alapvető az idiomatikus Ruby írásához és olvasásához — ezek a funkciók és konvenciók folyamatosan megjelennek, és azok megértése (különösen a kulcsszavas argumentumok az egyértelmű API-khoz és a ?/! konvenciók a metódus viselkedésének megértéséhez) elengedhetetlen, gyakran alkalmazott ismeret az effektív Ruby fejlesztéshez.