Question

I have two examples that give the same result.

With block:

def self.do_something(object_id)
  self.with_params(object_id) do |params|
    some_stuff(params)
  end
end

def self.with_params(object_id, &block)
  find_object_by_id
  calculate_params_hash
  block.call(params_hash)
end

and with method:

def self.do_something(object_id)
  some_stuff(self.get_params(object_id))
end

def self.get_params(object_id)
  find_object_by_id
  calculate_params_hash
  params_hash
end

The second solution seems more straightforward, but I found some usages of the first one in our application code. My question is: in which situation the first one is recommended? What are the pros and cons of each one?

Answer 1

The main difference between a block and function as per your example is that the block runs within the context of the calling function.

So if your example was as:

def self.do_something(object_id)
  x = "boogy on"
  self.with_params(object_id) do |params|
    some_stuff(params)
    puts x
  end
end

The code within the block can access the variable x that was defined outside the block. This is called a closure. You couldn’t do this if you were just calling a function as per your second example.

Another interesting thing about blocks is they can affect the control flow of the outer function. So it is possible to do :

def self.do_something(object_id)
  self.with_params(object_id) do |params|
    if some_stuff(params)
        return
    end
  end

  # This wont get printed if some_stuff returns true.
  puts "porkleworkle"
end

If the some_stuff call within the block returns a true value, the block will return. This will return out of the block and out of the dosomething method. porkleworkle would not get output.

In your examples you don’t rely on either of these, so using function calls is probably much cleaner.

However, there are many situations where using blocks to allow you to take advantage of these things is invaluable.