Ruby return Keyword

last modified October 18, 2026

This tutorial explains how to use Ruby's return keyword. The return statement controls method execution flow and output values.

The return keyword exits a method immediately and optionally provides a value. Without return, Ruby methods return the last evaluated expression.

Return statements make control flow explicit and allow early termination. Ruby collects multiple return values into an array.

Basic Method Return

This example shows a simple method with an explicit return statement. The method calculates and returns the square of a number.

basic_return.rb

def square(num)
  return num * num
end

result = square(5)
puts "The square is #{result}"

The return statement sends the calculated value back to the caller. Without it, the method would still work but explicit returns improve clarity.

Early Return from Method

Return statements can exit methods before reaching the end. This example checks input validity and returns early if invalid.

early_return.rb

def divide(a, b)
  return "Error: division by zero" if b == 0
  a / b
end

puts divide(10, 2)
puts divide(5, 0)

The method returns an error message immediately if the divisor is zero. This pattern avoids nested conditionals and improves readability.

Returning Multiple Values

Ruby methods can return multiple values using arrays. This example returns both quotient and remainder from division.

multiple_return.rb

def divmod(a, b)
  return [a / b, a % b]
end

quotient, remainder = divmod(10, 3)
puts "Quotient: #{quotient}, Remainder: #{remainder}"

The return statement packages both values in an array. The caller can destructure them into separate variables for convenient access.

Conditional Return Values

Methods can return different values based on conditions. This example implements a simple scoring system with tiered responses.

conditional_return.rb

def evaluate_score(score)
  return "Excellent!" if score >= 90
  return "Good job" if score >= 70
  return "Needs improvement" if score >= 50
  "Fail"
end

puts evaluate_score(95)
puts evaluate_score(65)

Each condition returns a different string. The final implicit return handles the lowest score case. This pattern creates readable decision trees.

Return in Blocks

The return keyword behaves differently in blocks versus methods. This example demonstrates how return exits the enclosing method, not just the block.

block_return.rb

def find_first_even(numbers)
  numbers.each do |n|
    return n if n.even?
  end
  nil
end

puts find_first_even([1, 3, 5, 2, 4])
puts find_first_even([1, 3, 5])

The return statement exits the entire method when finding an even number. Without it, each would continue through all elements, and the method would return nil if none were even.

Return in Procs and Lambdas

A lambda return exits only the lambda, so the surrounding method continues. A proc return exits the method where the proc was created. If that method has already returned, calling the proc raises LocalJumpError.

proc_lambda_return.rb

def lambda_vs_proc
  lambda_return = lambda { return :from_lambda }
  proc_return = proc { return :from_proc }

  puts lambda_return.call
  puts proc_return.call
  :method_end
end

puts lambda_vs_proc

def make_proc
  proc { return :too_late }
end

begin
  make_proc.call
rescue LocalJumpError => e
  puts "LocalJumpError: #{e.message}"
end

The lambda call prints from_lambda and continues. The proc call returns from lambda_vs_proc before its puts runs, so :method_end is never reached; the method returns :from_proc, which the outer puts prints. The detached proc then raises LocalJumpError because its defining method has already returned.

Return with begin-rescue

Return statements work with exception handling. This example shows how return values interact with rescue blocks.

rescue_return.rb

def safe_divide(a, b)
  begin
    a / b
  rescue ZeroDivisionError
    return "Cannot divide by zero"
  end
end

puts safe_divide(10, 2)
puts safe_divide(5, 0)

The method returns either the division result or an error message. The return in the rescue block provides an alternative execution path.

Explicit vs Implicit Return

This example compares explicit return statements with Ruby's implicit return behavior. Both styles work but have different use cases.

explicit_vs_implicit.rb

def explicit_return
  return "Hello"
  "World"
end

def implicit_return
  "Hello"
  "World"
end

puts explicit_return # Outputs "Hello"
puts implicit_return # Outputs "World"

The explicit return exits immediately, ignoring subsequent code. The implicit version evaluates all expressions and returns the last one.

Source

Ruby Keywords Documentation

This tutorial covered Ruby's return keyword with practical examples showing method control flow, multiple returns, and special cases.

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