Ruby methoden worden gedefinieerd met def...end. Ruby heeft flexibele, expressieve argument-afhandeling — standaardwaarden, keyword-argumenten, splat (*) voor variabele argumenten, en blokken — plus de conventie dat de laatste expressie de impliciete retourwaarde is.
()
a + b
add(, )
()
Ruby-methoden geven automatisch de laatst geëvalueerde expressie terug — je schrijft zelden return (het wordt alleen voor vroege returns gebruikt). Dit is idiomatisch.
# 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
Keyword-argumenten (name:) zijn idiomatisch modern Ruby — ze maken aanroepen zelf-documenterend en volgorde-onafhankelijk.
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 verzamelt variabele positie-argumenten in een array; **options verzamelt keyword-argumenten in een 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
Naamconventies: methoden eindigend op ? geven booleans terug (predikaten), en ! geeft aan dat het een destructieve/in-place of "gevaarlijke" versie is.
Methoden zijn de bouwstenen van gedrag in Ruby, en het begrijpen van Ruby's flexibele, expressieve argument-afhandeling en conventies is belangrijk dagelijks kennis.
Verschillende aspecten zijn specifiek voor Ruby en het waard om te kennen: de impliciete return (methoden geven de laatst geëvalueerde expressie terug, dus return wordt zelden geschreven — idiomatische Ruby vertrouwt hierop), keyword-argumenten (name: — de moderne, idiomatische manier om duidelijke, zelf-documenterende, volgorde-onafhankelijke methode-aanroepen te schrijven), en splat-argumenten (*args/**options voor variabel aantal argumenten).
Evenals belangrijk zijn de naamconventies — methoden eindigend op ? zijn predikaten die booleans teruggeven (valid?, empty?), en methoden eindigend op ! zijn destructieve/in-place of "gevaarlijke" versies (map!, sort!) — die doorlopend in Ruby en Rails voorkomen en het gedrag van een methode in één oogopslag communiceren (wetend dat ! typisch "wijzigt in place" betekent, is belangrijk om onbedoelde mutaties te vermijden).
Het begrijpen hoe je methoden met Ruby's flexibele argumenten (standaardwaarden, keywords, splats) definieert, het impliciete-return-idioom, en de ?/!-naamconventies is fundamenteel voor het schrijven en lezen van idiomatische Ruby — deze functies en conventies komen constant voor, en het ervan begrijpen (vooral keyword-argumenten voor schone API's en de ?/!-conventies voor het begrijpen van methode-gedrag) is essentieel, regelmatig toegepaste kennis voor effectieve Ruby-ontwikkeling.