Ruby-metoder definieras med def...end. Ruby har flexibel, uttrycksfull argumenthantering — standardvärden, nyckelordargument, splat (*) för variabelt antal argument och block — plus konventionen att det sista uttrycket är det implicita returvärdet.
()
a + b
add(, )
()
Ruby-metoder returnerar automatiskt det sista utvärderade uttrycket — du skriver sällan return (det används endast för tidig return). Detta är idiomatiskt.
# 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
Nyckelordargument (name:) är idiomatisk modern Ruby — de gör anrop själv-dokumenterande och ordningsoberoende.
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 samlar variabla positionella argument till en array; **options samlar nyckelordargument till 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
Namngivningskonventioner: metoder som slutar med ? returnerar booleska värden (predikat), och ! indikerar en destruktiv/på-plats eller "farlig" version.
Metoder är byggstenarna för beteende i Ruby, och att förstå Rubys flexibla, uttrycksfulla argumenthantering och konventioner är viktig daglig kunskap.
Flera aspekter är särskilt Ruby och värd att veta: den implicita returnen (metoder returnerar det sista utvärderade uttrycket, så return skrivs sällan — idiomatisk Ruby förlitar sig på detta), nyckelordargument (name: — det moderna, idiomatiska sättet att skriva tydliga, själv-dokumenterande, ordningsoberoende metodanrop), och splat-argument (*args/**options för variabelt antal argument).
Lika viktiga är namngivningskonventionerna — metoder som slutar med ? är predikat som returnerar booleska värden (valid?, empty?), och metoder som slutar med ! är destruktiva/på-plats eller "farliga" versioner (map!, sort!) — som är genomgripande i Ruby och Rails och kommunicerar en metods beteende på ett ögonblick (att veta att ! typiskt betyder "modifierar på plats" är viktigt för att undvika oavsiktliga mutationer).
Att förstå hur man definierar metoder med Rubys flexibla argument (standardvärden, nyckelord, splat), den implicita-return-idiomen och namnkonventionerna ?/! är grundläggande för att skriva och läsa idiomatisk Ruby — dessa funktioner och konventioner förekommer ständigt, och att förstå dem (särskilt nyckelordargument för rena API:er och konventionerna ?/! för att förstå metod-beteende) är väsentlig, ofta använd kunskap för effektiv Ruby-utveckling.