A block is a chunk of code passed to a method, enclosed in { } (one line) or do...end (multi-line). Blocks are a distinctive, central Ruby feature — they're how you pass behavior to methods, powering iteration, callbacks, and Ruby's elegant, expressive style.
[, , ].each { || puts n }
[, , ].each ||
doubled = n *
puts doubled
A block is passed to a method (here each), which calls the block for each element. The |n| declares the block's parameter (the value passed in). Both syntaxes are equivalent; convention uses { } for short blocks and do...end for longer ones.
[1, 2, 3, 4].map { |n| n * 2 } # [2, 4, 6, 8] — transform each
[1, 2, 3, 4].select { |n| n.even? } # [2, 4] — filter
[1, 2, 3, 4].reduce(0) { |sum, n| sum + n } # 10 — accumulate
3.times { |i| puts i } # 0, 1, 2
[1, 2, 3].each_with_index { |val, i| ... }
Blocks are how Ruby does iteration and data transformation — you pass the "what to do" as a block, and the method handles the iteration. This is more elegant than explicit loops.
# blocks elegantly handle setup/teardown — the file is auto-closed after the block
File.open("data.txt") do |file|
puts file.read
end # file automatically closed here, even if an error occurs
Methods can use blocks for setup/cleanup patterns (like ensuring a file is closed) — the method handles the resource, calling your block in between.
[1, 2, 3].map { |n| n.to_s } # full block
[1, 2, 3].map(&:to_s) # shorthand — &:method calls that method on each element
["a", "b"].map(&:upcase) # ["A", "B"]
The &:method shorthand is a concise idiom for blocks that just call one method on each element.
Blocks are one of Ruby's most distinctive and central features — they're fundamental to how Ruby works and to its elegant, expressive style, so understanding them is essential for any Ruby development.
Blocks are how you pass behavior to methods, which powers Ruby's signature approach to iteration and data transformation: instead of writing explicit loops, you pass a block describing what to do with each element (map, select, reduce, each), and the method handles the iteration — resulting in concise, readable, functional-style code that's quintessentially Ruby.
Blocks also enable elegant resource management patterns (a method handles setup/teardown, like auto-closing a file, calling your block in between).
Understanding block syntax ({ } vs do...end), how blocks receive parameters (|n|), how they power the Enumerable methods that appear constantly in Ruby, and idioms like the &:method shorthand is foundational, must-know knowledge — blocks appear in virtually every line of idiomatic Ruby (every iteration, transformation, and many method calls).
Since blocks are central to Ruby's design and expressive style — enabling its elegant iteration, callbacks, and resource-management patterns — mastering them is absolutely essential for reading and writing Ruby, and they're a defining feature that distinguishes Ruby's approach from languages relying on explicit loops, making them a frequent and important topic for understanding the language.