Use of yield and return in Ruby

Question

Can anyone help me to figure out the the use of yield and return in Ruby. I'm a Ruby beginner, so simple examples are highly appreciated.

Thank you in advance!

Blastosphere

Answer 1

The return statement works the same way that it works on other similar programming languages, it just returns from the method it is used on. You can skip the call to return, since all methods in ruby always return the last statement. So you might find method like this:

def method
  "hey there"
end

That's actually the same as doing something like:

def method
  return "hey there"
end

The yield on the other hand, excecutes the block given as a parameter to the method. So you can have a method like this:

def method 
  puts "do somthing..."
  yield
end

And then use it like this:

method do
   puts "doing something"
end

The result of that, would be printing on screen the following 2 lines:

"do somthing..."
"doing something"

Hope that clears it up a bit. For more info on blocks, you can check out this link.

Emergent

The link to blocks is broken – Hotbed

Here's a good one link – Hotbed

Answer 2

yield is used to call the block associated with the method. You do this by placing the block (basically just code in curly braces) after the method and its parameters, like so:

[1, 2, 3].each {|elem| puts elem}

return exits from the current method, and uses its "argument" as the return value, like so:

def hello
  return :hello if some_test
  puts "If it some_test returns false, then this message will be printed."
end

But note that you don't have to use the return keyword in any methods; Ruby will return the last statement evaluated if it encounters no returns. Thus these two are equivelent:

def explicit_return
  # ...
  return true
end

def implicit_return
  # ...
  true
end

---

Here's an example for yield:

# A simple iterator that operates on an array
def each_in(ary)
  i = 0
  until i >= ary.size
    # Calls the block associated with this method and sends the arguments as block parameters.
    # Automatically raises LocalJumpError if there is no block, so to make it safe, you can use block_given?
    yield(ary[i])
    i += 1
  end
end

# Reverses an array
result = []     # This block is "tied" to the method
                #                            | | |
                #                            v v v
each_in([:duck, :duck, :duck, :GOOSE]) {|elem| result.insert(0, elem)}
result # => [:GOOSE, :duck, :duck, :duck]

And an example for return, which I will use to implement a method to see if a number is happy:

class Numeric
  # Not the real meat of the program
  def sum_of_squares
    (to_s.split("").collect {|s| s.to_i ** 2}).inject(0) {|sum, i| sum + i}
  end

  def happy?(cache=[])
    # If the number reaches 1, then it is happy.
    return true if self == 1
    # Can't be happy because we're starting to loop
    return false if cache.include?(self)
    # Ask the next number if it's happy, with self added to the list of seen numbers
    # You don't actually need the return (it works without it); I just add it for symmetry
    return sum_of_squares.happy?(cache << self)
  end
end

24.happy? # => false
19.happy? # => true
2.happy?  # => false
1.happy?  # => true
# ... and so on ...

Hope this helps! :)

Mellie

@Mellie shouldn't it be def happy?(cache=[])? – Ashti

@Aᴍɪʀ Thanks, fixed – Mellie

Answer 3

def cool
  return yield
end

p cool {"yes!"}

The yield keyword instructs Ruby to execute the code in the block. In this example, the block returns the string "yes!". An explicit return statement was used in the cool() method, but this could have been implicit as well.

Spinster