A blokk egy kódcsipet, amelyet egy metódusnak adunk át, { } zárójelbe foglalva (egy sor) vagy do...end (többsoros). A blokkok a Ruby megkülönböztetõ, központi jellemzõi — így adunk át viselkedést a metódusoknak, amely lehetõvé teszi az iterációt, callback-eket, és a Ruby elegáns, kifejezõ stílusát.
[, , ].each { || puts n }
[, , ].each ||
doubled = n *
puts doubled
Egy blokk átadódik a metódusnak (itt az each), amely meghívja a blokkot minden elemhez. A |n| deklarálja a blokk paraméterét (az átadott érték). Mindkét szintaxis ekvivalens; a konvenció a { } rövidebb blokkokhoz és a do...end hosszabbakhoz ajánlja.
[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| ... }
A blokkok azért vannak a Rubyban, hogy lehetõvé tegyék az iterációt és az adattranszformációt — átadsz egy "mit csináljak" blokkot, és a metódus kezeli az iterációt. Ez elegánsabb, mint az explicit ciklusok.
# 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
A metódusok blokkokat használhatnak inicializálásra/tisztításra (például annak biztosítására, hogy egy fájl bezárásra kerül) — a metódus kezeli az erõforrást, és meghívja a blokkot közben.
[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"]
A &:metódus rövidítés egy tömör idiómája a blokkoknak, amely csak egy metódust hív meg az egyes elemekre.
A blokkok a Ruby egyik legmegkülönböztetõbb és legközpontosabb jellemzõi — alapvetõek ahhoz, hogy a Ruby hogyan mûködik, és annak elegáns, kifejezõ stílusához, ezért ezek megértése elengedhetetlen a Ruby fejlesztéshez.
A blokkok azok az eszközök, amelyekkel viselkedést adunk át a metódusoknak, amely lehetõvé teszi a Ruby jellegzetes iterációs és adattranszformációs megközelítését: ahelyett, hogy explicit ciklusokat írnánk, átadunk egy blokkot, amely leírja, mit csináljunk az egyes elemekkel (map, select, reduce, each), és a metódus kezeli az iterációt — rezultálva rövid, olvasható, funkcionális stílusú kódban, amely tipikusan Ruby.
A blokkok lehetõvé teszik az elegáns erõforrás-kezelési mintákat is (egy metódus kezeli az inicializálást/lezárást, mint például egy fájl automatikus bezárása, és meghívja a blokkot közben).
A blokk szintaxisának megértése ({ } vs do...end), hogy a blokkok hogyan kapnak paramétereket (|n|), hogy hogyan hajtják végre az Enumerable metódusokat, amelyek állandóan megjelennek a Rubyban, valamint az idiómák, mint a &:metódus rövidítés alapvetõ, szükséges tudás — a blokkok szinte minden sorában megjelennek az idiomatikus Rubynak (minden iteráció, transzformáció és sok metódushívás).
Mivel a blokkok a Ruby tervezésének és kifejezõ stílusának központi része — lehetõvé teszik az elegáns iterációt, callback-eket és erõforrás-kezelési mintákat — az elsajátításuk abszolút nélkülözhetetlen a Ruby olvasásához és írásához, és olyan megkülönböztetõ jellemzõ, amely a Ruby megközelítéseit megkülönbözteti az explicit ciklusokra támaszkodó nyelvektõl, így gyakori és fontos téma a nyelv megértéséhez.