Ruby Yield

Key Yield Concepts

yield

yield(value)

block_given?

3.times { yield }

🔹 Basic Yield Usage

The yield keyword transfers control to the block provided by the caller. When yield executes, Ruby runs the block's code, then returns control back to the method.

# Method with yield
def say_hello
  puts "Start"
  yield
  puts "End"
end

say_hello { puts "Hello from block!" }

🔹 Yield with Parameters

Pass data from your method to the block using yield with arguments. The block receives these values as parameters, allowing it to work with method data dynamically.

# Yield with arguments
def calculate(a, b)
  result = yield(a, b)
  puts "Result: #{result}"
end

calculate(5, 3) { |x, y| x + y }
calculate(5, 3) { |x, y| x * y }

🔹 Checking for Blocks

Use block_given? to make blocks optional in your methods. This prevents errors when no block is provided and allows your method to handle both cases gracefully.

# Optional block
def process_data(data)
  puts "Processing: #{data}"
  
  if block_given?
    yield(data)
  else
    puts "No custom processing"
  end
end

process_data("Hello")
process_data("Hello") { |d| puts "Custom: #{d.upcase}" }

🔹 Multiple Yields

Call yield multiple times within a method to execute the block repeatedly. This is useful for iteration, callbacks, or any scenario where you need to run the same code multiple times.

# Yield multiple times
def repeat(times)
  times.times do |i|
    yield(i + 1)
  end
end

repeat(3) { |num| puts "Iteration #{num}" }

🔹 Yield with Return Values

Blocks can return values back to the method through yield. The method can capture and use these return values to make decisions or perform calculations based on block results.

# Capture block return value
def transform(value)
  result = yield(value)
  puts "Original: #{value}, Transformed: #{result}"
end

transform(5) { |n| n * 2 }
transform("hello") { |s| s.upcase }

🔹 Practical Yield Example

Create a timing method that measures how long a block takes to execute. This demonstrates a real-world use case where yield enables flexible, reusable utility methods.

# Measure execution time
def measure_time
  start_time = Time.now
  yield
  end_time = Time.now
  puts "Execution time: #{(end_time - start_time).round(3)} seconds"
end

measure_time do
  sum = 0
  1000.times { |i| sum += i }
  puts "Sum calculated: #{sum}"
end

🔹 Array Iteration with Yield

Build custom iteration methods using yield to process array elements. This shows how Ruby's built-in methods like each are implemented and how you can create similar functionality.

# Custom each method
def my_each(array)
  i = 0
  while i < array.length
    yield(array[i])
    i += 1
  end
end

my_each([1, 2, 3, 4]) { |num| puts "Number: #{num}" }