Using do block vs braces {}

Question

New to ruby, put on your newbie gloves.

Is there any difference (obscure or practical) between the following two snippets?

my_array = [:uno, :dos, :tres]
my_array.each { |item| 
    puts item
}

my_array = [:uno, :dos, :tres]
my_array.each do |item| 
    puts item
end

I realize the brace syntax would allow you to place the block on one line

my_array.each { |item| puts item }

but outside of that are there any compelling reasons to use one syntax over the other?

Answer 1

Ruby cookbook says bracket syntax has higher precedence order than do..end

Keep in mind that the bracket syntax has a higher precedence than the do..end syntax. Consider the following two snippets of code:

1.upto 3 do |x|
  puts x
end

1.upto 3 { |x| puts x }
# SyntaxError: compile error

Second example only works when parentheses is used, 1.upto(3) { |x| puts x }

Answer 2

This is a bit old question but I would like to try explain a bit more about {} and do .. end

like it is said before

bracket syntax has higher precedence order than do..end

but how this one makes difference:

method1 method2 do
  puts "hi"
end

in this case, method1 will be called with the block of do..end and method2 will be passed to method1 as an argument! which is equivalent to method1(method2){ puts "hi" }

but if you say

method1 method2{
  puts "hi"
}

then method2 will be called with the block then the returned value will be passed to method1 as an argument. Which is equivalent to method1(method2 do puts "hi" end)

def method1(var)
    puts "inside method1"
    puts "method1 arg = #{var}"
    if block_given?
        puts "Block passed to method1"
        yield "method1 block is running"
    else
        puts "No block passed to method1"
    end
end

def method2
    puts"inside method2"
    if block_given?
        puts "Block passed to method2"
        return yield("method2 block is running")
    else
        puts "no block passed to method2"
        return "method2 returned without block"
    end
end

#### test ####

method1 method2 do 
    |x| puts x
end

method1 method2{ 
    |x| puts x
}

#### output ####

#inside method2
#no block passed to method2
#inside method1
#method1 arg = method2 returned without block
#Block passed to method1
#method1 block is running

#inside method2
#Block passed to method2
#method2 block is running
#inside method1
#method1 arg = 
#No block passed to method1

Answer 3

There are two common styles for choosing do end vs. { } for blocks in Ruby:

The first and very common style was popularized by Ruby on Rails, and is based on a simple rule of single vs. multi-line:

• Use braces { } for single-line blocks
• Use do end for multi-line blocks

This makes sense because do/end reads badly in a one-liner, but for multi-line blocks, leaving a closing } hanging on its own line is inconsistent with everything else that uses end in ruby, such as module, class & method definitions (def etc.) and control structures (if, while, case, etc.)

The second, less-frequently seen style is known as semantic, or "Weirich Braces", proposed by the late, great rubyist Jim Weirich:

• Use do end for procedural blocks
• Use braces { } for functional blocks

This means that when the block is evaluated for its return value, it should be chainable, and the {} braces make more sense for method chaining.

On the other hand, when the block is evaluated for its side-effects, then the return value is of no consequence, and the block is just "doing" something, so it does not make sense to be chained.

This distinction in the syntax conveys visual meaning about the evaluation of the block, and whether or not you should care about its return value.

For example, here the return value of the block is applied to every item:

items.map { |i| i.upcase }

However, here it's not using the block's return value. It's operating procedurally, and doing a side-effect with it:

items.each do |item|
  puts item
end

Another benefit of the semantic style is that you don't need to change braces to do/end just because a line was added to the block.

As an observation, coincidentally functional blocks are frequently a one-liner, and procedural blocks (e.g. config) are multi-line. So, following the Weirich style ends up looking almost the same as the Rails style.

Answer 4

Generally, the convention is to use {} when you are doing a small operation, for example, a method call or a comparison, etc. so this makes perfect sense:

some_collection.each { |element| puts element }

But if you have slightly complex logic that goes to multiple lines then use do .. end like:

1.upto(10) do |x|
  add_some_num = x + rand(10)
  puts '*' * add_some_num
end

Basically, it comes down to, if your block logic goes to multiple lines and cannot be fitted on the same line then use do .. end and if your block logic is simple and just a simple/single line of code then use {}.