In Ruby there are many methods that accept blocks, one of the first that comes to mind is the times method that allows us to run specific block X times.
Now it's time to learn how to create a method that can accept (and use) a block.
Everything is done by the magic word yield.
Define a method that accepts a block is pretty simple, all you have to do is add yield in the body of the method like so:
def my_method
puts "This is the start of my method."
yield
puts "This is the end of my method."
end
And you're done.
Now you can call your method with a block:
my_method do
puts "This text comes from the block"
end
Basically the method stops what it's doing to let the block take over and run the code we specify in it, but there's more...
First and foremost you can add yield as many times as you want, doing so the code in the block will just get executed as many times as yield is present. So if we change the method in:
def my_method
puts "This is the start of my method."
yield
yield
yield
puts "This is the end of my method."
end
We get:
my_method do
puts "This text comes from the block"
end
But obviously, there are some gotchas.
The first one that probably you'll face creating your methods that accept blocks is that you have to pass a block to it otherwise you'll get a LocalJumpError.
In order to make it conditional, you have to use the method block_given?
Pass a parameter to the block
As it happens for times or upto you are able to pass parameters to the blocks that can be used within the block itself, you just need to pass it to yield as follows:
def my_method
puts "This is the start of my method."
yield "Andrea"
puts "This is the end of my method."
end
And when we use it we get the following:
my_method do |name|
puts "The name you passed is #{name}"
end
Return values from a block
Probably the method you're creating needs to do something with the value calculated in the block, so it's time to know how to handle it.
The most important thing to notice is that the implicit return, the ability of a Ruby method to return the value of the last expression, is available in the blocks as well.
This means that your blocks are already returning values, you just are not using them.
In order to make our method aware of the returned value we just have to change it by storing the value, you guess, in a variable:
def my_method
puts "This is the start of my method."
result = yield "Andrea"
puts "This is the end of my method and the result from the block is #{result}."
end
Now the result holds the value returned from the block, here's an example:
my_method do |name|
puts "The name you passed is #{name}"
rand(1..5)
end
Resources
Those notes are taken while following the Ruby Blocks course at Pragmatic Studio.
