Ruby methods are defined with def...end. Ruby has flexible, expressive argument handling — default values, keyword arguments, splat (*) for variable arguments, and blocks — plus the convention that the last expression is the implicit return value.
()
a + b
add(, )
()
Ruby methods return the last evaluated expression automatically — you rarely write return (it's used only for early returns). This is idiomatic.
# 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 arguments (name:) are idiomatic modern Ruby — they make calls self-documenting and order-independent.
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 collects variable positional arguments into an array; **options collects keyword arguments into a 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
Naming conventions: methods ending in ? return booleans (predicates), and ! indicates a destructive/in-place or "dangerous" version.
Methods are the building blocks of behavior in Ruby, and understanding Ruby's flexible, expressive argument handling and conventions is important everyday knowledge.
Several aspects are distinctly Ruby and worth knowing: the implicit return (methods return the last evaluated expression, so return is rarely written — idiomatic Ruby relies on this), keyword arguments (name: — the modern, idiomatic way to write clear, self-documenting, order-independent method calls), and splat arguments (*args/**options for variable numbers of arguments).
Equally important are the naming conventions — methods ending in ? are predicates returning booleans (valid?, empty?), and methods ending in ! are destructive/in-place or "dangerous" versions (map!, sort!) — which are pervasive in Ruby and Rails and communicate a method's behavior at a glance (knowing that ! typically means "modifies in place" is important for avoiding unintended mutations).
Understanding how to define methods with Ruby's flexible arguments (defaults, keywords, splats), the implicit-return idiom, and the ?/! naming conventions is foundational for writing and reading idiomatic Ruby — these features and conventions appear constantly, and grasping them (especially keyword arguments for clean APIs and the ?/! conventions for understanding method behavior) is essential, frequently-applied knowledge for effective Ruby development.