---
title: "Ruby Blocks Tutorial"
url: https://weworkworldwide.com/tutorials/ruby-blocks-tutorial/
description: "Ruby Blocks Tutorial: In this section we will learn what the blocks are and how to use them in Ruby. What is block in Ruby?"
date: 2026-11-10T13:00:03+00:00
source: https://weworkworldwide.com/llms.txt
---

# Ruby Blocks Tutorial

In this section we will learn what the blocks are and how to use them in Ruby.

## What is block in Ruby?

A Ruby block is just a body where you can write code there and pass this block to methods that accept block as their input.

The methods then run the written source code in the block when we call those methods.

You can somehow think about it as a method without a name! But there are some differences here and in order to learn them, let’s first get into the details of how to create a block in the first place.

## Defining a Method that Takes a Block in Ruby

Alright, creating a block has two phases:

-   First you define a method that is capable of taking a  
    block.

-   Then you create a block that can be passed to a method (this part  
    is explained in the section down below).

So in order to create a method to be able to take a block as its argument, we set its last parameter like this:

&block

Note that the last parameter starts with the & character. (The name of the parameter doesn’t matter and it could be anything as long as it starts with the & symbol.)

For example:

``` line-numbers
def function_name (param1, param2, &block)
```

Now within the body of the method if we want to call that block, we need to use the specified name (but without the & symbol) and call the “call” method.

Note: a block is treated as an object within the body of a method and it has a method called “call”. Now in order to invoke the target block in your method, all you need to do is to invoke the “call” method.

For example:

``` line-numbers
def function_name (param1, param2, &block)
```

block.call #this will invoke the body of the target block to be executed.

end

## How to create a block in Ruby? (Ruby Block Syntax)

Alright, after creating a method that is able able to take blocks, now we need to know how to create a block and pass that to such type of method!

Well, first of all, a block is created whenever we are calling a method that takes a block! Basically, it’s not like we first create a block somewhere and store it for later use! No, a block is created right when a method that needs a block is getting called.

We can create a block in two different ways:

– using do-end: The do-end syntax defines the border of a block and then we can write the necessary instructions within the body of that block.

Example:

function_name (argument1, argument2) do

#instructions of the block…

end

In this example we’re calling the function_name as if it has two parameters and so we’re passing two arguments for those parameters. But then comes the `do-end` block where we defined the instructions of the block.

As you can see the block is created right where the function is called.

Note: we don’t need to pass a block as the argument of a method just like the way we pass arguments to other parameters of a method! The accepted method of passing a block to a method is the way you saw above.

Note that other than using `do-end` syntax, we can use a pair of curly braces `{}` that defines the border to the block.

Be aware that the convention is to use the curly braces when there’s only one expression in the target block!

For example:

``` line-numbers
function_name(argument1, argument2) { #expression of the block }
```

## Example: creating a block in Ruby using do-end syntax

``` line-numbers
def block_function (&block)
puts "The message before calling the block"
block.call
puts "The message after calling the block"
end
block_function do
puts "The message of the block"
end
Output:
The message before calling the block
The message of the block
The message after calling the block
```

## Flow of control between a Method and Block

In this example, the `block_function` does not take any parameter except for the &block. This means the method is of those types that needs a block when we call it.

Also you can see that in the body of the `block_function` we’ve called the block using the `call` method.

Now whenever this method is called, it should be followed with a block.

Alright, a little about the flow of control now:

When we first called the `block_function`, the program started to run the first and second instructions within the body of the method.

After that it faces a call to the block.

So at this stage, it stops executing instructions within the block_function and moves into the body of the block we’ve defined for it.

Now it runs the instructions within the body of the block (which there’s only one statement and that’s a call to the puts method).

After finishing the execution of the entire instructions within the body of the block, your program will return to the body of the function right where the call to the block happened and continues to run the rest of instructions in that function.

Note: if there’s a method that takes a block and you don’t set a block for it at the time of calling it, you’ll get an error as a result.

## Example: creating a block in Ruby using a pair of braces

Alright, let’s refactor the example above, and this time use the curly braces to define the border of the block.

``` line-numbers
def block_function (&block)
```

puts “The message before calling the block”

block.call

puts “The message after calling the block”

end

``` line-numbers
block_function { puts "The message of the block"}
```

Output:

The message before calling the block

The message of the block

The message after calling the block

## Defining a Method that takes a Block using Ruby yield Keyword

Other than setting the last parameter of a method to make it accept blocks, we can use the yield keyword as well.

If we use this keyword inside the body of a method, that means the method takes a block as well. Basically just by using the yield keyword within the body of a method, we won’t need to modify the last parameter of the target parameter.

## Example: using yield keyword to create a method that takes a block

``` line-numbers
def block_function
puts "The message before calling the block"
yield
puts "The message after calling the block"
end
block_function { puts "The message of the block"}
Output:
The message before calling the block
The message of the block
The message after calling the block
```

As you can see, now the method is capable of taking a block but yet we didn’t add a parameter using & for this method.

## Calling the same method with different Block in Ruby

When setting a method to work with a block, we can set different blocks with different body for that method everytime the method is called.

## Example: calling the same method with different block in Ruby

``` line-numbers
def block_function
puts "The message before calling the block"
yield
puts "The message after calling the block"
end
block_function { puts "The message of the block"}
puts "The second time we call the method..............."
block_function do
puts "This is another block with different body"
puts "Hello from the second block 🙂 "
end
Output:
The message before calling the block
The message of the block
The message after calling the block
```

The second time we call the method……………

The message before calling the block

This is another block with different body

Hello from the second block 🙂

The message after calling the block

Here every time we call a method that takes a block, your program will jump into that block right after the yield statement is executed within the method.

## Ruby Blocks with Parameters

So far, we’ve been working with blocks that didn’t take any argument! But blocks are also capable of taking arguments!

This is done when calling the `yield` statement. Basically here we put any number of arguments that the target block needs.

For example:

yield arg1, arg2, arg3

The statement above means the target block needs three arguments to function properly.

Now let’s see how we can define a set of parameters for a block.

## Ruby Blocks with Parameters Syntax:

``` line-numbers
{ |param1, param2, param_n| #instructions}
do
|param1, param2, param_n|
#instructions…
end
```

As you can see, within the body of the block we put two pipes `||` and inside those pipes, define the needed parameters.

## Example: creating blocks with parameters

``` line-numbers
def block_function
puts "The message before calling the block"
yield "John","Doe"
puts "The message after calling the block"
end
block_function do |first_name, last_name|
puts "The values that was passed to the block are: #{first_name}, #{last_name}"
end
Output:
The message before calling the block
The values that was passed to the block are: John, Doe
The message after calling the block
```

## Ruby Blocks with Parameters Note:

Just like the parameters of methods that are capable of taking optional (default) default values, we can set optional values for the parameters of blocks as well.

## Ruby Block: Calling a block multiple times

Within the body of a method you’re not limited to just call a block once! As matter of fact you can call the block using the yield statement as many times as you needed.

That way, every time your program sees the yield statement, it will stop the program and jumps into the block to run the instructions there and after that it will return to the method again to continue running the rest of instructions there.

## Example: calling a block multiple times in Ruby

``` line-numbers
def block_function
puts "The message before calling the block"
yield "John","Doe"
puts "***"
yield "Omid","Dehghan"
puts "***"
yield "Elon","Musk"
puts "The message after calling the block"
end
block_function do |first_name, last_name|
puts "The values that was passed to the block are: #{first_name}, #{last_name}"
end
Output:
The message before calling the block
The values that was passed to the block are: John, Doe
***
The values that was passed to the block are: Omid, Dehghan
***
The values that was passed to the block are: Elon, Musk
The message after calling the block
```

In this example, within the body of the block_function we have three calls to the block using the yield statement and so your program will jump into the block to run its instructions three times as a result.

## More to Read:

``` line-numbers
Ruby blocks with return value Tutorial
```