Ruby Blocks

Key Block Concepts

5.times { puts "Hi" }
5.times do
  puts "Hello"
end

[1, 2].each do |n|
  puts n
end

arr.each { |item|
  puts item
}

def run
  yield
end

🔹 Block Syntax

Ruby offers two ways to write blocks: curly braces for single-line blocks and do...end for multi-line blocks. Both work identically, but convention suggests using braces for short, simple operations.

# Curly braces - single line
3.times { puts "Hello" }

# do...end - multiple lines
3.times do
  puts "Hello"
  puts "World"
end

# With parameters
[1, 2, 3].each { |num| puts "Number: #{num}" }

# Multi-line with parameters
["apple", "banana"].each do |fruit|
  puts "I like #{fruit}"
  puts "It's delicious!"
end

🔹 Common Block Methods

Ruby's enumerable methods use blocks extensively for iteration and transformation. These built-in methods make working with collections intuitive and expressive, reducing the need for traditional loops in most cases.

# each - iterate through items
[1, 2, 3].each { |n| puts n * 2 }

# map - transform each item
doubled = [1, 2, 3].map { |n| n * 2 }
puts doubled.inspect

# select - filter items
evens = [1, 2, 3, 4, 5].select { |n| n.even? }
puts evens.inspect

# times - repeat n times
5.times { |i| puts "Iteration #{i}" }

# upto - count up
1.upto(3) { |n| puts "Count: #{n}" }

🔹 Creating Methods with Blocks

You can create your own methods that accept blocks using the yield keyword. This allows you to build custom iteration patterns and reusable code structures that execute caller-provided logic at specific points.

# Simple yield
def greet
  puts "Before block"
  yield
  puts "After block"
end

greet { puts "Inside block!" }

# Yield with parameters
def repeat(n)
  n.times { |i| yield(i) }
end

repeat(3) { |num| puts "Number: #{num}" }

# Conditional yield
def maybe_run
  yield if block_given?
  puts "Method complete"
end

maybe_run { puts "Block executed" }
maybe_run  # No block provided

🔹 Block Parameters

Blocks can receive multiple parameters from the calling method. These parameters are defined between pipe characters and allow blocks to access iteration values, indices, or any data the method wants to share.

# Single parameter
[10, 20, 30].each { |num| puts num }

# Multiple parameters
hash = { name: "Alice", age: 25 }
hash.each { |key, value| puts "#{key}: #{value}" }

# With index
["a", "b", "c"].each_with_index do |letter, index|
  puts "#{index}: #{letter}"
end

# Custom method with multiple yields
def calculate(a, b)
  yield(a, b, a + b)
end

calculate(5, 3) { |x, y, sum| puts "#{x} + #{y} = #{sum}" }

🔹 Practical Block Examples

Blocks shine in real-world scenarios like data processing, file operations, and custom iterations. These examples demonstrate how blocks make Ruby code elegant, readable, and powerful for everyday programming tasks.

# Data transformation
prices = [10, 20, 30]
discounted = prices.map { |price| price * 0.9 }
puts "Discounted: #{discounted.inspect}"

# Filtering data
numbers = [1, 2, 3, 4, 5, 6]
evens = numbers.select { |n| n.even? }
odds = numbers.reject { |n| n.even? }
puts "Evens: #{evens.inspect}"
puts "Odds: #{odds.inspect}"

# Custom iterator
def countdown(from)
  from.downto(1) { |n| yield(n) }
  puts "Blast off!"
end

countdown(3) { |n| puts n }

# Accumulation
total = [1, 2, 3, 4].reduce(0) { |sum, n| sum + n }
puts "Total: #{total}"