Een block is een stuk code dat aan een methode wordt doorgegeven, ingesloten in { } (één regel) of do...end (meerdere regels). Blocks zijn een kenmerkend, centraal Ruby-kenmerk — ze zijn hoe je gedrag aan methoden doorgeeft, wat iteratie, callbacks en Ruby's elegante, expressieve stijl mogelijk maakt.
[, , ].each { || puts n }
[, , ].each ||
doubled = n *
puts doubled
Een block wordt aan een methode doorgegeven (hier each), die de block voor elk element aanroept. De |n| declareert de parameter van de block (de waarde die wordt doorgegeven). Beide syntaxvarianten zijn equivalent; conventie gebruikt { } voor korte blocks en do...end voor langere.
[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 zijn hoe Ruby iteratie en gegevenstransformatie doet — je geeft het "wat te doen" als een block door, en de methode verzorgt de iteratie. Dit is eleganter dan expliciete 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
Methoden kunnen blocks gebruiken voor setup/cleanup-patronen (zoals het waarborgen dat een bestand wordt gesloten) — de methode verzorgt de resource, en roept je block daartussen aan.
[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"]
De &:method snelschrift is een beknopt idioom voor blocks die alleen één methode op elk element aanroepen.
Blocks zijn een van Ruby's meest kenmerkende en centrale kenmerken — ze zijn fundamenteel voor hoe Ruby werkt en voor zijn elegante, expressieve stijl, dus het begrijpen ervan is essentieel voor elke Ruby-ontwikkeling.
Blocks zijn hoe je gedrag aan methoden doorgeeft, wat Ruby's karakteristieke benadering van iteratie en gegevenstransformatie mogelijk maakt: in plaats van expliciete loops te schrijven, geef je een block door die beschrijft wat je met elk element wilt doen (map, select, reduce, each), en de methode verzorgt de iteratie — wat resulteert in beknopt, leesbaar, functionele code die typisch Ruby is.
Blocks maken ook elegante resourcebeheer-patronen mogelijk (een methode verzorgt setup/teardown, zoals het automatisch sluiten van een bestand, en roept je block daartussen aan).
Het begrijpen van block-syntaxis ({ } vs do...end), hoe blocks parameters ontvangen (|n|), hoe ze de Enumerable-methoden mogelijk maken die constant in Ruby voorkomen, en idiomen zoals de &:method snelschrift is fundamentele, must-know-kennis — blocks verschijnen in vrijwel elke regel idiomatische Ruby (elke iteratie, transformatie, en veel methodeaanroepen).
Omdat blocks centraal in Ruby's ontwerp en expressieve stijl staan — waardoor de elegante iteratie, callbacks en resourcebeheer-patronen mogelijk worden — is het beheersen ervan absoluut essentieel voor het lezen en schrijven van Ruby, en ze zijn een kenmerkend kenmerk dat Ruby's benadering onderscheidt van talen die op expliciete loops vertrouwen, waardoor ze een frequent en belangrijk onderwerp zijn voor het begrijpen van de taal.