what is the point of return in Ruby?

What is the difference between return and just putting a variable such as the following:

###no return

def write_code(number_of_errors)
  if number_of_errors > 1
     mood = "Ask me later"
  else
     mood = "No Problem"
  end  
  mood
end

###return

def write_code(number_of_errors)
  if number_of_errors > 1
    mood =  "Ask me later"
  else
    mood = puts "No Problem"
  end  
  return mood
end

return allows you to break out early:

def write_code(number_of_errors)
  return "No problem" if number_of_errors == 0
  badness = compute_badness(number_of_errors)
  "WHAT?!  Badness = #{badness}."
end

If number_of_errors == 0, then "No problem" will be returned immediately. At the end of a method, though, it's unnecessary, as you observed.

---

Edit: To demonstrate that return exits immediately, consider this function:

def last_name(name)
  return nil unless name
  name.split(/\s+/)[-1]
end

If you call this function as last_name("Antal S-Z"), it will return "S-Z". If you call it as last_name(nil), it returns nil. If return didn't abort immediately, it would try to execute nil.split(/\s+/)[-1], which would throw an error.

Using "return" is unnecessary if it is the last line to be executed in the method, since Ruby automatically returns the last evaluated expression.

You don't even need that final "mood", nor do you need those assignments in the IF statement.

def write_code(number_of_errors)
    if number_of_errors > 1
       "ERROR"
    else
       "No Problem"
    end  
end

puts write_code(10)

Output:

> ERROR

I use return when I'm going through a list, and I want to exit the function if any member of the list meets a criteria. I could accomplish this with a single statement like:

list.select{|k| k.meets_criteria}.length == 0

in some situations, but

list.each{|k| return false if k.meets_criteria}

is one line too--with, to my mind, some added flexibility. For example, the first example assumes that this is the only line in the method, and that we want to return from this point no matter what. But if this is a test to see whether it is safe to proceed with the rest of the method, the first example will need to handle that in a different way.

EDIT:

To add some flexibility, consider the following line of code:

list_of_method_names_as_symbols.each{|k| list_of_objects.each{|j| return k if j.send(k)}}

I'm sure this can be accomplished, in one line, without return, but off the top of my head I don't see how.

But this is now a fairly flexible line of code that can be called with any list of boolean methods and a list of objects that implement those methods.

EDIT

It should be noted that I'm assuming this line is inside a method, not a block.

---

But this is mostly a stylistic choice, I think that in most situations, you can and possibly should avoid using return.

Ruby returns always! the best way is

def write_code(number_of_errors)
  (number_of_errors > 1)? "ERROR" : "No Problem"
end

it means that if number_of_errors > 1 it will return ERROR else No Problem

Its nice ruby gives this good feature of not specifying return statement explicitly but I just feel, as a programming standard, one should always strive to specify "return" statements wherever required. This helps in making code more readable for someone who is coming from different background like C++, Java, PHP etc. and learning ruby. "return" statement will not harm anything, so why skip conventional and more standard way of returning from functions.

One small caution for those coming from other languages. Say you have a function like the OP's, and you make use of the "last thing computed" rule to set your return value automagically:

def write_code(number_of_errors)
  if number_of_errors > 1
     mood = "Ask me later"
  else
     mood = "No Problem"
  end  
end

and let's say you add a debugging (or logging) statement:

def write_code(number_of_errors)
  if number_of_errors > 1
     mood = "Ask me later"
  else
     mood = "No Problem"
  end  
  puts "### mood = #{mood}"
end

Now guess what. You've broken your code, because the puts returns nil, which now becomes the return value from the function.

The solution is to get in the habit of always explicitly putting the return value on the last line, the way the OP did:

def write_code(number_of_errors)
  if number_of_errors > 1
     mood = "Ask me later"
  else
     mood = "No Problem"
  end  
  puts "### mood = #{mood}"
  mood
end

Unnecesarity of return at the last line in function is just syntaxic sugar of Ruby. In most procedural languages you need to write return in each (non-void in C++) function.