Os métodos do Ruby são definidos com def...end. Ruby possui tratamento de argumentos flexível e expressivo — valores padrão, argumentos de palavra-chave, splat (*) para argumentos variáveis e blocos — além da convenção de que a última expressão é o valor de retorno implícito.
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
Os métodos do Ruby retornam a última expressão avaliada automaticamente — raramente você escreve return (é usado apenas para retornos antecipados). Isso é idiomático.
# 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
Argumentos de palavra-chave (name:) são idiomáticos no Ruby moderno — eles tornam as chamadas auto-documentáveis e independentes de ordem.
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 coleta argumentos posicionais variáveis em um array; **options coleta argumentos de palavra-chave em um 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ções de nomenclatura: métodos terminados em ? retornam booleanos (predicados), e ! indica uma versão destrutiva/in-place ou "perigosa".
Os métodos são os blocos de construção do comportamento em Ruby, e entender o tratamento flexível e expressivo de argumentos do Ruby e suas convenções é conhecimento importante do dia a dia.
Vários aspectos são distintamente Ruby e valem a pena conhecer: o retorno implícito (métodos retornam a última expressão avaliada, então return raramente é escrito — Ruby idiomático conta com isso), argumentos de palavra-chave (name: — a forma moderna e idiomática de escrever chamadas de métodos claras, auto-documentáveis e independentes de ordem), e argumentos splat (*args/**options para números variáveis de argumentos).
Igualmente importantes são as convenções de nomenclatura — métodos terminados em ? são predicados que retornam booleanos (valid?, empty?), e métodos terminados em ! são versões destrutivas/in-place ou "perigosas" (map!, sort!) — que são onipresentes em Ruby e Rails e comunicam o comportamento de um método num relance (saber que ! normalmente significa "modifica in-place" é importante para evitar mutações não intencionais).
Entender como definir métodos com argumentos flexíveis do Ruby (padrões, palavras-chave, splats), a idioma de retorno implícito e as convenções de nomenclatura ?/! é fundamental para escrever e ler Ruby idiomático — essas funcionalidades e convenções aparecem constantemente, e compreendê-las (especialmente argumentos de palavra-chave para APIs limpas e as convenções ?/! para entender o comportamento do método) é conhecimento essencial e frequentemente aplicado para o desenvolvimento eficaz em Ruby.