Ruby def Keyword

last modified October 18, 2026

This tutorial explains how to use Ruby's def keyword to define methods. Methods are fundamental building blocks in Ruby programs.

The def keyword defines a method with a name, parameters, and body. Methods encapsulate behavior and can be called multiple times. They help organize code into reusable units.

Ruby methods can take arguments, return values, and have default parameters. They can be defined on objects or classes. Method names follow naming conventions, and operators such as + and [] can also be defined as methods.

Basic Method Definition

This simple example demonstrates the most basic method definition. The method takes no parameters and performs a simple operation.

basic_method.rb

def greet
  puts "Hello, Ruby!"
end

greet
greet

The def keyword starts the method definition, followed by the method name. The method body contains the code to execute. The method is called by its name. This example calls greet twice.

Method with Parameters

Methods often take parameters to make them more flexible. This example shows a method that accepts one parameter.

method_with_param.rb

def greet(name)
  puts "Hello, #{name}!"
end

greet("Alice")
greet("Bob")

The method greet now takes a name parameter. The parameter is used in string interpolation. We call the method with different arguments to produce different outputs.

Method with Default Parameters

Ruby allows default parameter values. When an argument isn't provided, the default value is used.

default_params.rb

def greet(name = "Ruby")
  puts "Hello, #{name}!"
end

greet("Alice")
greet

The name parameter defaults to "Ruby" when no argument is given. The first call provides an argument, while the second uses the default. Default parameters make methods more flexible.

Method with Return Value

Methods can return values explicitly with return. Without an explicit return, a method returns the value of its last evaluated expression.

return_value.rb

def square(x)
  x * x
end

def absolute(x)
  return -x if x < 0
  x
end

result = square(5)
puts "5 squared is #{result}"
puts "Absolute value: #{absolute(-5)}"

The square method returns the square of its argument, which is stored in result. Ruby returns the last expression's value automatically, so return is optional there. The absolute method uses an explicit return to leave the method early when the number is negative.

Multiple Parameters

Methods can accept multiple parameters. This example shows a method that calculates the sum of three numbers.

multiple_params.rb

def sum(a, b, c)
  a + b + c
end

total = sum(10, 20, 30)
puts "The sum is #{total}"

The sum method takes three parameters and returns their sum. We pass three arguments when calling the method. Ruby evaluates the addition expression and returns the result.

Variable Number of Arguments

Ruby methods can accept variable numbers of arguments using the splat operator (*). This is useful for flexible method definitions.

variable_args.rb

def average(*numbers)
  numbers.sum.to_f / numbers.size
end

puts average(1, 2, 3)
puts average(10, 20, 30, 40, 50)

The *numbers parameter collects all arguments into an array. We calculate the average by summing and dividing by count. The method works with any number of arguments.

Keyword Arguments

Ruby supports keyword arguments for more readable method calls. Parameters are passed by name rather than position.

keyword_args.rb

def create_person(name:, age:, occupation: "Developer")
  { name: name, age: age, occupation: occupation }
end

person = create_person(name: "Alice", age: 30)
puts person.inspect

The method defines keyword parameters. name and age are required; occupation has a default value. We call it using keyword syntax, which makes the call descriptive and independent of argument order. Parameters with defaults are optional.

Source

Ruby Methods Documentation

This tutorial covered Ruby's def keyword with examples showing method definition, parameters, return values, and advanced features.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Ruby tutorials.

Ebooks