Why Block given? check in Ruby? - Purpose & Use Cases

The Big Idea

What if your method could know when you want it to do something extra--and when not to--without breaking?

The Scenario

Imagine you write a method that sometimes needs extra instructions from the user, but other times it works fine on its own. Without a way to check if those extra instructions are given, your method might crash or behave unexpectedly.

The Problem

Manually guessing if extra instructions (blocks) are provided can lead to errors or complicated code. You might try to call a block that doesn't exist, causing your program to stop suddenly. This makes your code fragile and hard to maintain.

The Solution

Ruby's block_given? method lets you easily check if a block was passed to your method. This way, you can safely decide whether to run the block or skip it, making your code more flexible and error-free.

Before vs After

✗ Before

def greet
  yield
end

greet # Error if no block given

✓ After

def greet
  if block_given?
    yield
  else
    puts 'Hello!'
  end
end

greet # Works fine with or without block

What It Enables

You can write methods that adapt smoothly whether or not extra instructions (blocks) are provided, making your code smarter and safer.

Real Life Example

Think of a greeting method that says a default hello if no special message is given, but uses a custom message if you provide one as a block.

Key Takeaways

Without checking, calling a missing block causes errors.

block_given? safely detects if a block is present.

This makes methods flexible and prevents crashes.

Practice

1. What does the Ruby method block_given? check inside a method?

easy

A. If the method is defined inside a class

B. If the method has any parameters

C. If the method returns a value

D. If a block was passed to the method

Solution

1. Step 1: Understand the purpose of block_given?

   This method returns true if the current method was called with a block passed to it.

2. Step 2: Differentiate from other method checks

   It does not check parameters, return values, or class definitions, only the presence of a block.

3. Final Answer:

   If a block was passed to the method -> Option D

4. Quick Check:

   block_given? checks block presence = A [OK]

Hint: block_given? tells if a block is passed to method [OK]

Common Mistakes:

• Confusing block_given? with method parameters
• Thinking it checks return values
• Assuming it checks class membership

2. Which of the following is the correct syntax to check if a block was given inside a Ruby method?

easy

A. if block_given then yield end

B. if block_given? () yield end

C. if block_given? then yield end

D. if block_given? yield () end

Solution

1. Step 1: Identify correct method call syntax

   block_given? is a method and should be called with a question mark and optionally parentheses. The most common and clear syntax is block_given? without parentheses.

2. Step 2: Confirm correct use of yield

   The yield keyword runs the block if it exists. The syntax if block_given? then yield end is correct and clear.

3. Final Answer:

   if block_given? then yield end -> Option C

4. Quick Check:

   Correct syntax uses block_given? and yield [OK]

Hint: Use block_given? with question mark and yield inside if [OK]

Common Mistakes:

• Omitting question mark in block_given?
• Using block_given without parentheses incorrectly
• Calling yield with parentheses unnecessarily

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

def greet
  if block_given?
    yield
  else
    puts "Hello!"
  end
end

greet { puts "Hi there!" }
greet

medium

A. Hi there!\nHello!

B. Hello!\nHello!

C. Hi there!\nHi there!

D. No output

Solution

1. Step 1: Analyze first greet call with block

   The first call passes a block that prints "Hi there!". Since block_given? is true, yield runs the block, printing "Hi there!".

2. Step 2: Analyze second greet call without block

   The second call has no block, so block_given? is false and the else branch runs, printing "Hello!".

3. Final Answer:

   Hi there!\nHello! -> Option A

4. Quick Check:

   Block runs first, then default message = A [OK]

Hint: Block runs if given; else default runs [OK]

Common Mistakes:

• Assuming yield runs even without block
• Thinking both calls print the same message
• Confusing order of outputs

4. Identify the error in this Ruby method:

def show
  yield if block_given
end

show { puts "Hello!" }

medium

A. Missing question mark in block_given method call

B. yield cannot be used without arguments

C. Method show requires a parameter

D. Block cannot be passed to show method

Solution

1. Step 1: Check block_given usage

   The method block_given? requires the question mark and should be called as block_given? or block_given?(). Here it is missing the question mark.

2. Step 2: Confirm yield usage

   The yield is correctly used and does not require arguments here. The method does not require parameters to accept a block.

3. Final Answer:

   Missing question mark in block_given method call -> Option A

4. Quick Check:

   block_given? needs question mark [OK]

Hint: Always use block_given? with question mark [OK]

Common Mistakes:

• Omitting question mark in block_given
• Thinking yield needs arguments always
• Assuming method needs parameters for blocks

5. You want to write a Ruby method process_items that takes an array and optionally a block. If a block is given, it should yield each item to the block; otherwise, it should return the array unchanged. Which code correctly implements this behavior?

hard

A. def process_items(arr)
arr.each { |item| yield item if block_given? }
end

B. def process_items(arr)
if block_given?
arr.each { |item| yield item }
else
arr
end
end

C. def process_items(arr)
if block_given
arr.each { |item| yield item }
else
arr
end
end

D. def process_items(arr)
arr.each { |item| yield item }
end

Solution

1. Step 1: Check block presence correctly

   def process_items(arr) if block_given? arr.each { |item| yield item } else arr end end uses block_given? correctly to check if a block is passed before yielding.

2. Step 2: Handle both cases properly

   If a block is given, it yields each item; otherwise, it returns the original array unchanged, matching the requirement.

3. Step 3: Review other options for errors

   def process_items(arr) arr.each { |item| yield item } end always yields without checking block presence, causing error if no block given. def process_items(arr) if block_given arr.each { |item| yield item } else arr end end misses question mark in block_given. def process_items(arr) arr.each { |item| yield item if block_given? } end yields conditionally inside each, but block_given? inside the each block always returns false so no yielding occurs, though it returns the array.

4. Final Answer:

   def process_items(arr) if block_given? arr.each { |item| yield item } else arr end end -> Option B

5. Quick Check:

   Check block_given? before yield and return array if no block [OK]

Hint: Check block_given? before yield; else return array [OK]

Common Mistakes:

• Not checking block_given? before yield
• Missing question mark in block_given
• Returning nil instead of array when no block