Los métodos de Ruby se definen con def...end. Ruby tiene un manejo de argumentos flexible y expresivo — valores por defecto, argumentos nombrados, splat (*) para argumentos variables, y bloques — además de la convención de que la última expresión es el 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
Los métodos de Ruby retornan la última expresión evaluada automáticamente — raramente escribes return (se usa solo para retornos anticipados). Esto es 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
Los argumentos nombrados (name:) son idiomáticos en Ruby moderno — hacen que las llamadas sean auto-documentadas e independientes del orden.
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 recopila argumentos posicionales variables en un array; **options recopila argumentos nombrados en un 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
Convenciones de nombres: métodos que terminan en ? retornan booleanos (predicados), y ! indica una versión destructiva/in-place o "peligrosa".
Los métodos son los bloques de construcción del comportamiento en Ruby, y entender el manejo flexible y expresivo de argumentos de Ruby y sus convenciones es conocimiento importante del día a día.
Varios aspectos son distintivamente Ruby y vale la pena conocer: el retorno implícito (los métodos retornan la última expresión evaluada, por lo que return raramente se escribe — Ruby idiomático se basa en esto), argumentos nombrados (name: — la forma moderna e idiomática de escribir llamadas claras, auto-documentadas e independientes del orden), y argumentos splat (*args/**options para números variables de argumentos).
Igualmente importantes son las convenciones de nombres — métodos que terminan en ? son predicados que retornan booleanos (valid?, empty?), y métodos que terminan en ! son versiones destructivas/in-place o "peligrosas" (map!, sort!) — que son ubicuas en Ruby y Rails y comunican el comportamiento de un método de un vistazo (saber que ! típicamente significa "modifica in-place" es importante para evitar mutaciones no intencionales).
Entender cómo definir métodos con argumentos flexibles de Ruby (por defecto, nombrados, splats), el idioma de retorno implícito, y las convenciones de nombres ?/! es fundamental para escribir y leer Ruby idiomático — estas características y convenciones aparecen constantemente, y dominarlas (especialmente argumentos nombrados para APIs limpias y las convenciones ?/! para entender el comportamiento del método) es conocimiento esencial y frecuentemente aplicado para el desarrollo efectivo en Ruby.