yield calls the block passed to a method — it transfers control to the block, optionally passing values to it, then resumes the method. It's how methods invoke the blocks given to them, and the mechanism behind Ruby's iteration and many elegant patterns.
puts
puts
greet { puts }
When a method calls yield, it runs the block that was passed to it (in { } or do...end). The method controls when (and how many times) the block runs.
def each_pair
yield("a", 1) # pass values to the block's parameters
yield("b", 2)
end
each_pair { |key, value| puts "#{key}: #{value}" }
# Output: a: 1 / b: 2
yield(args) passes values to the block's parameters (|key, value|) — this is how iteration methods give each element to the block.
def my_each(array)
i = 0
while i < array.length
yield(array[i]) # yield each element to the block
i += 1
end
end
my_each([1, 2, 3]) { |n| puts n * 2 } # 2, 4, 6
# this is essentially how Array#each works internally!
This shows how Ruby's iteration methods (each, map, etc.) work internally — they yield each element to the block.
def maybe_yield
if block_given? # check whether a block was passed (avoid an error)
yield
else
"no block"
end
end
# explicitly capture the block as a parameter (with &)
def run(&block) # &block captures the block as a Proc object
block.call # call it explicitly
end
block_given? checks if a block was passed (avoiding a LocalJumpError), and &block captures the block as a Proc object you can store or pass on.
Understanding yield is important Ruby knowledge — it's the mechanism behind how methods invoke blocks, which underpins Ruby's signature iteration and many elegant patterns, so grasping it illuminates how much of Ruby actually works. yield calls the block passed to a method (transferring control to it, optionally passing values), which is precisely how Ruby's iteration methods (each, map, select) operate internally — they yield each element to the block.
Understanding this demystifies Ruby's block-based iteration and lets you write your own methods that accept blocks — a powerful capability for creating expressive APIs, custom iterators, resource-management methods (setup/teardown around a block), and DSLs.
Knowing yield (calling the block, passing arguments to it), block_given? (safely checking whether a block was passed, avoiding errors), and &block (explicitly capturing the block as a Proc) is important for both understanding how Ruby's iteration and block-accepting methods work and for writing your own block-based methods.
Since blocks are central to Ruby and yield is how methods use them, understanding yield deepens your grasp of Ruby's most distinctive feature (blocks) and enables you to write the kind of elegant, block-accepting methods that make Ruby expressive — a valuable skill for building clean APIs and a common interview topic that reflects understanding of how Ruby's block mechanism actually functions under the hood.