RubyDev - The Home for Ruby Developers

Return Values & Early Returns

Understanding how Ruby methods return values is crucial for effective programming. Ruby's implicit return system, early returns, and multiple return values make methods flexible and expressive.

Implicit vs Explicit Returns

Return Values: Ruby methods automatically return the last evaluated expression. Use explicit return for early exits, multiple returns, or when you want to be clear about the return value.

Implicit Returns (Ruby Style)

# Implicit return - Ruby style
def
square(n)
  n * n # This value is automatically returned
end

def
calculate_total(items)
  total = 0
  items.each { |item| total += item.price }
  total # Last expression is returned
end

def
format_name(first, last)
  if first.nil? || last.nil?
    "Unknown" # Returns this if condition is true
  else
    "\#{first} \#{last}" # Returns this if condition is false
  end
end

Explicit Returns

# Explicit return for early exits
def
divide_safely(a, b)
  return "Cannot divide by zero" if b == 0
  a / b
end

def
find_user(id)
  return nil unless id.is_a?(Integer)
  return nil if id <= 0
  
  # Main logic here
  User.find(id)
end

Multiple Return Values

Multiple Returns: Ruby methods can return multiple values using arrays. Use parallel assignment to capture multiple return values elegantly.

Multiple Return Value Examples

# Return multiple values as an array
def
min_max(array)
  [array.min, array.max] # Returns array with two values
end

def
divide_with_remainder(a, b)
  [a / b, a % b] # Returns quotient and remainder
end

def
parse_name(full_name)
  parts = full_name.split
  [parts.first, parts[1..-1].join(" ")] # [first_name, last_name]
end

# Using multiple return values
min, max = min_max([3, 1, 4, 1, 5])
puts
"Min: \#{min}, Max: \#{max}"
# "Min: 1, Max: 5"

quotient, remainder = divide_with_remainder(17, 5)
puts
"17 ÷ 5 = \#{quotient} remainder \#{remainder}"
# "17 ÷ 5 = 3 remainder 2"

first, last = parse_name("John Michael Smith")
puts
"First: \#{first}, Last: \#{last}"
# "First: John, Last: Michael Smith"

Guard Clauses Pattern

Guard Clauses: Use early returns to handle edge cases and invalid inputs at the beginning of methods. This reduces nesting and makes code more readable.

Guard Clause Examples

# Guard clauses for early validation
def
process_user(user)
  return false unless user
  return false unless user.valid?
  return false unless user.active?
  
  # Main processing logic here
  user.process!
end

def
calculate_discount(price, discount_percent)
  return 0 if price <= 0
  return 0 if discount_percent <= 0
  return price if discount_percent >= 100
  
  price * (discount_percent / 100.0)
end

def
send_notification(user, message)
  return nil unless user&.email
  return nil if message.blank?
  return nil unless user.notification_enabled?
  
  # Send notification logic
  NotificationService.send(user.email, message)
end

Interactive Practice: Return Values & Early Returns

Practice Time: Try these return value examples and experiment with different return patterns. Understanding return values will make you a more effective Ruby programmer.

Interactive Code Runner

Ruby Code Editor

# Try these comprehensive return value examples!

# 1. Implicit returns (Ruby style)
def square(n)
  n * n  # This value is automatically returned
end

puts square(5)  # 25

# 2. Explicit returns
def divide_safely(a, b)
  return "Cannot divide by zero" if b == 0
  a / b
end

puts divide_safely(10, 2)  # 5
puts divide_safely(10, 0)  # "Cannot divide by zero"

# 3. Multiple return values
def min_max(array)
  [array.min, array.max]  # Returns an array
end

min, max = min_max([3, 1, 4, 1, 5, 9, 2, 6])
puts "Min: #{min}, Max: #{max}"

# 4. Guard clauses pattern
def process_user(user)
  return "No user provided" unless user
  return "User inactive" unless user[:active]
  return "No email" unless user[:email]
  
  "Processing user: #{user[:name]} (#{user[:email]})"
end

puts process_user(nil)
puts process_user({ name: "John", active: false })
puts process_user({ name: "Jane", active: true })
puts process_user({ name: "Bob", active: true, email: "bob@example.com" })

# 5. Conditional returns
def get_status(score)
  case score
  when 90..100
    "Excellent"
  when 80..89
    "Good"
  when 70..79
    "Average"
  when 60..69
    "Below Average"
  else
    "Needs Improvement"
  end
end

puts get_status(95)  # "Excellent"
puts get_status(75)  # "Average"
puts get_status(45)  # "Needs Improvement"

# 6. Early returns with calculations
def calculate_discount(price, user_type, is_member)
  return 0 unless price > 0
  return 0 unless is_member
  
  base_discount = case user_type
                  when "premium" then 0.20
                  when "regular" then 0.10
                  else 0.05
                  end
  
  price * base_discount
end

puts calculate_discount(100, "premium", true)  # 20.0
puts calculate_discount(100, "regular", true)  # 10.0
puts calculate_discount(100, "guest", false)   # 0

# 7. Return different types
def get_user_info(user_id)
  return nil if user_id.nil? || user_id <= 0
  
  if user_id == 1
    { name: "Alice", email: "alice@example.com", role: "admin" }
  elsif user_id == 2
    { name: "Bob", email: "bob@example.com", role: "user" }
  else
    "User not found"
  end
end

puts get_user_info(1)
puts get_user_info(2)
puts get_user_info(999)
puts get_user_info(nil)

# Add your own return value experiments below!

Output will appear here when you run the code...

Best Practices & Common Patterns

✅ Best Practices

Use implicit returns for simple, single-purpose methods
Use explicit returns for early exits and guard clauses
Return meaningful values that indicate success/failure
Use multiple returns for related data
Be consistent with return value types
Document complex return value patterns

❌ Common Pitfalls

Forgetting that methods always return something
Using explicit return when implicit would suffice
Inconsistent return value types
Not handling edge cases with early returns
Returning nil without clear intent
Overusing multiple return values

Return Values Mastery Summary

You've Mastered Return Values!

Implicit Returns

Ruby's automatic return of the last expression

Early Returns

Guard clauses and explicit return statements

Multiple Returns

Returning arrays for multiple values

Understanding return values is essential for writing clean, predictable Ruby methods. Use implicit returns for simplicity, explicit returns for control flow, and multiple returns for related data.

Return Values & Early Returns

Return Values & Early Returns

Implicit vs Explicit Returns

Implicit Returns (Ruby Style)

Explicit Returns

Multiple Return Values

Multiple Return Value Examples

Guard Clauses Pattern

Guard Clause Examples

Interactive Practice: Return Values & Early Returns

Interactive Code Runner

Ruby Code Editor

Best Practices & Common Patterns

✅ Best Practices

❌ Common Pitfalls

Return Values Mastery Summary

You've Mastered Return Values!

Implicit Returns

Early Returns

Multiple Returns

Quick Navigation

Related Topics

Video Tutorial

Ruby Language

Rails Framework

Production Ready

Return Values & Early Returns

Return Values & Early Returns

Implicit vs Explicit Returns

Implicit Returns (Ruby Style)

Explicit Returns

Multiple Return Values

Multiple Return Value Examples

Guard Clauses Pattern

Guard Clause Examples

Interactive Practice: Return Values & Early Returns

Interactive Code Runner

Ruby Code Editor

Best Practices & Common Patterns

✅ Best Practices

❌ Common Pitfalls

Return Values Mastery Summary

You've Mastered Return Values!

Implicit Returns

Early Returns

Multiple Returns

Quick Navigation

Related Topics

Video Tutorial