Why blocks are fundamental to Ruby - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Ruby code using a block?

Consider the following Ruby code that uses a block with the method times. What will it print?

Ruby

3.times do |i|
  puts i * 2
end

A

1
2
3

B

0
2
4

C

0
1
2

D

2
4
6

💡 Hint

Remember that the block variable i starts at 0 and goes up to one less than the number.

The times method runs the block 3 times with i values 0, 1, and 2. Multiplying each by 2 gives 0, 2, and 4.

🧠 Conceptual

intermediate

Why are blocks important in Ruby?

Which of the following best explains why blocks are fundamental to Ruby?

A Blocks are a way to write comments that the interpreter ignores.

B Blocks are used only for defining classes and modules in Ruby.

C Blocks replace variables and constants in Ruby programs.

D Blocks allow methods to accept chunks of code to be executed later, enabling flexible iteration and callbacks.

💡 Hint

Think about how blocks let you pass code to methods like each or map.

Blocks let you pass a piece of code to a method, which can run it multiple times or at specific moments. This makes Ruby very flexible and expressive.

🔧 Debug

advanced

What error does this Ruby code raise?

Look at this Ruby code using a block. What error will it raise when run?

Ruby

def greet
  yield
  yield('friend')
end

greet do |name|
  puts "Hello, #{name}!"
end

A ArgumentError: wrong number of arguments (given 0, expected 1)

B SyntaxError: unexpected keyword_end

C NoMethodError: undefined method 'yield' for main:Object

D No error, prints 'Hello, !' and 'Hello, friend!'

💡 Hint

Check how many arguments the block expects and how many are passed.

The block expects one argument (name), but the first yield call passes none, causing an ArgumentError.

📝 Syntax

advanced

Which option correctly defines a method that takes a block and calls it twice?

Choose the Ruby code that defines a method twice which calls the given block two times.

A

def twice
  yield
  yield
end

B

def twice
  yield()
  yield()
end

C All of the above

D

def twice(&block)
  block.call
  block.call
end

💡 Hint

Blocks can be called with yield or by passing an explicit block parameter.

All three ways correctly call the block twice. Option C and C use yield, B uses an explicit block parameter.

🚀 Application

expert

What is the output of this Ruby code using blocks and enumerators?

Analyze this Ruby code and select the exact output it produces.

Ruby

result = (1..5).map do |n|
  if n.even?
    n * 2
  else
    n
  end
end

puts result.inspect

A

[1, 4, 3, 8, 5]

B

[2, 4, 6, 8, 10]

C

[1, 2, 3, 4, 5]

D

[1, 8, 3, 16, 5]

💡 Hint

Remember that n.even? checks if a number is even, and map transforms each element.

For even numbers (2 and 4), the block returns n * 2 (4 and 8). For odd numbers, it returns n unchanged. So the array becomes [1, 4, 3, 8, 5].

Practice

1. What is a block in Ruby?

easy

A. A type of variable that stores numbers

B. A chunk of code passed to a method to be executed

C. A method that returns a value

D. A special kind of loop that runs forever

Solution

1. Step 1: Understand what a block is

   A block is a piece of code enclosed in braces {} or do..end that you can pass to a method.

2. Step 2: Identify the role of a block

   Blocks allow methods to execute the passed code at specific times, making code flexible.

3. Final Answer:

   A chunk of code passed to a method to be executed -> Option B

4. Quick Check:

   Block = code passed to method [OK]

Hint: Blocks are code chunks given to methods to run [OK]

Common Mistakes:

• Thinking blocks are variables
• Confusing blocks with methods
• Believing blocks are loops

2. Which of the following is the correct syntax to pass a block to a method in Ruby?

easy

A. method_name { |param| puts param }

B. method_name (|param| puts param)

C. method_name -> { puts param }

D. method_name [|param| puts param]

Solution

1. Step 1: Recognize Ruby block syntax

   Blocks are passed using curly braces {} or do..end after the method call.

2. Step 2: Match the correct syntax

   method_name { |param| puts param } uses curly braces with a block parameter and code inside, which is correct.

3. Final Answer:

   method_name { |param| puts param } -> Option A

4. Quick Check:

   Curly braces or do..end define blocks [OK]

Hint: Use {} or do..end after method for blocks [OK]

Common Mistakes:

• Using parentheses instead of braces for blocks
• Confusing lambda syntax with blocks
• Using square brackets for blocks

3. What will be the output of this Ruby code?

def greet
  yield 'Ruby'
end
greet { |name| puts "Hello, #{name}!" }

medium

A. greet

B. Hello, name!

C. Hello, Ruby!

D. SyntaxError

Solution

1. Step 1: Understand the method and block interaction

   The method greet calls yield with the string 'Ruby', which passes it to the block parameter 'name'.

2. Step 2: Evaluate the block execution

   The block prints "Hello, #{name}!" where name is 'Ruby', so it prints "Hello, Ruby!".

3. Final Answer:

   Hello, Ruby! -> Option C

4. Quick Check:

   yield passes 'Ruby' to block [OK]

Hint: yield runs block with given argument [OK]

Common Mistakes:

• Thinking yield returns method name
• Confusing block parameter with string literal
• Expecting syntax error due to yield

4. Identify the error in this Ruby code:

def repeat
  3.times do
    yield
  end
end
repeat { puts 'Hi' }

medium

A. SyntaxError due to missing block parameter

B. Method repeat is undefined

C. RuntimeError because yield has no block

D. No error, code runs and prints 'Hi' three times

Solution

1. Step 1: Analyze the method definition

   The method repeat calls 3.times and yields to the block each time.

2. Step 2: Check the block passed to repeat

   The block prints 'Hi', so it will print 'Hi' three times without error.

3. Final Answer:

   No error, code runs and prints 'Hi' three times -> Option D

4. Quick Check:

   yield with block runs fine [OK]

Hint: yield needs a block; here block is given [OK]

Common Mistakes:

• Assuming yield needs parameters
• Thinking missing block parameter causes error
• Confusing method name with undefined

5. How can blocks make Ruby code more flexible? Choose the best explanation.

hard

A. Blocks allow methods to accept custom code to run, changing behavior without rewriting methods

B. Blocks store data permanently for later use

C. Blocks replace variables to save memory

D. Blocks automatically optimize code speed

Solution

1. Step 1: Understand the role of blocks in flexibility

   Blocks let methods run different code passed by the user, so methods can do many tasks without changing their code.

2. Step 2: Evaluate the options

   Blocks allow methods to accept custom code to run, changing behavior without rewriting methods. This is the best explanation. The other choices are wrong: blocks do not replace variables to save memory, store data permanently for later use, or automatically optimize code speed.

3. Final Answer:

   Blocks allow methods to accept custom code to run, changing behavior without rewriting methods -> Option A

4. Quick Check:

   Blocks = flexible method behavior [OK]

Hint: Blocks let methods run custom code passed in [OK]

Common Mistakes:

• Thinking blocks store data like variables
• Believing blocks speed up code automatically
• Confusing blocks with memory management