What is use of ||= begin....end block in Ruby?

Question

What is difference in these two code snippets:

   def config
    @config ||= begin
      if config_exists?  
        @config = return some value
      else
        {}
      end
    end
  end

and

  def config
    @config ||= method
  end

  def method
    if config_exists?
      return some value
    else
      {}
    end
  end

I'm confused with the "begin ... end" block. Does it make any difference in the output? If not, then what is use of the begin ... end block here?

Answer 1

In your case, you can even omit the begin ... end block:

@config ||=
  if config_exists?  
    return_some_value
  else
    {}
  end

or, using the ternary if:

@config ||= config_exists? ? return_some_value : {}

Does it make any difference in output?

It could make a difference, because unlike def ... end, an begin ... end block doesn't create a new variable scope.

Here's a contrived example:

def foo
  a = 456  # doesn't affect the other a
end

a = 123
b = foo

p a: a, b: b #=> {:a=>123, :b=>456}

Versus:

a = 123
b = begin
  a = 456  # overwrites a
end

p a: a, b: b #=> {:a=>456, :b=>456}

Answer 2

First of all, you need to be aware that a defined method inherently includes the functionality of a begin ... end block.

In the context of exception handling, def method_name ... end is functionally equivalent to begin ... end. Both can include rescue statements for example.

The two blocks of code you have shared are actually identical, and there is no benefit in one over the other ... unless your method is needed in more than one place. In that case, you DRY up your code by putting the logic into a single method and calling it from multiple other places.