Ruby metoder defineres med def...end. Ruby har fleksibel, udtryksfuld argumenthåndtering — standardværdier, keyword-argumenter, splat (*) for variable argumenter og blokke — plus konventionen om at det sidste udtryk er den implicitte returværdi.
()
a + b
add(, )
()
Ruby-metoder returnerer det sidste evaluerede udtryk automatisk — du skriver sjældent return (det bruges kun til tidlig returnering). Dette er idiomatisk.
# 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-argumenter (name:) er idiomatisk moderne Ruby — de gør kald selv-dokumenterende og uafhængige af rækkefølge.
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 indsamler variable positionelle argumenter i et array; **options indsamler keyword-argumenter i en 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
Navngivningskonventioner: metoder der ender med ? returnerer boolske værdier (prædikat), og ! indikerer en destruktiv/in-place eller "farlig" version.
Metoder er byggeklodser for opførsel i Ruby, og det er vigtig hverdagsviden at forstå Rubys fleksible, udtryksfulde argumenthåndtering og konventioner.
Flere aspekter er særeget for Ruby og værd at kende: den implicitte return (metoder returnerer det sidste evaluerede udtryk, så return skrives sjældent — idiomatisk Ruby stoler på dette), keyword-argumenter (name: — den moderne, idiomatiske måde at skrive klare, selv-dokumenterende, rækkefølge-uafhængige metodekald), og splat-argumenter (*args/**options for variabelt antal argumenter).
Ligeledes vigtig er navngivningskonventionerne — metoder der ender med ? er prædikat-returner boolske værdier (valid?, empty?), og metoder der ender med ! er destruktive/in-place eller "farlige" versioner (map!, sort!) — som er udbredt i Ruby og Rails og kommunikerer en metodes opførsel på et øjeblik (at vide at ! typisk betyder "ændrer in-place" er vigtig for at undgå utilsigtede mutationer).
At forstå hvordan man definerer metoder med Rubys fleksible argumenter (standardværdier, keywords, splats), den implicitte-return-idiom og ?/!-navngivningskonventionerne er fundamentalt for at skrive og læse idiomatisk Ruby — disse funktioner og konventioner optræder konstant, og at forstå dem (især keyword-argumenter for rene API'er og ?/!-konventionerne for at forstå metodeopførsel) er afgørende, hyppigt-anvendt viden for effektiv Ruby-udvikling.