What is the return point in Ruby?

Question

What is the difference between return and just putting a variable, for example:

return is not refundable

 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 

Answer 1

return allows you to break through 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. However, at the end of the method, this is not necessary, as you noticed.

---

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 SZ") , it will return "SZ" . If you call it last_name(nil) , it returns nil . If return not interrupted immediately, it will try to execute nil.split(/\s+/)[-1] , which will cause an error.

Answer 2

Using "return" is not required if this is the last line to be executed in the method, since Ruby will automatically return the last evaluated expression.

You don’t even need this final “mood”, and you don’t need these 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) 

Exit:

MISTAKE

Answer 3

I use return when I scroll through the list, and I want to exit the function if any member of the list matches the criteria. I could accomplish this with a single statement, for example:

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

in some situations but

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

- also one line - in my opinion, 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 it's a test to make sure it's safe to continue working with the rest of the method, the first example will have to handle it differently.

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 am sure that this can be achieved in one line, without return , but from the top of my head I do not see how to do this.

But now this is a rather flexible line of code that can be called by any list of logical methods and a list of objects that implement these methods.

EDIT

It should be noted that I assume that this line is inside the method, not the block.

---

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

Answer 4

Ruby is always back! The best way -

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

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

Answer 5

A good ruby ​​gives this good opportunity not to specify the return statement explicitly, but I just feel that as standard programming you should always strive to specify "return" statements wherever needed. This helps to make the code more readable for those who come from different sources, such as C ++, Java, PHP, etc., and study ruby. The "return" operation does no harm, so why skip the normal and more standard way of returning from functions.

Answer 6

One small warning for those coming from other languages. Suppose you have a function like OP, and you use the "last thing calculated" rule to automatically set the return value:

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

and suppose you add a debug statement (or a log entry):

 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 violated your code because puts returns nil, which now becomes the return value from the function.

The solution is to get used to always explicitly specify the return value in the last line, as 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 

Answer 7

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