Enumerable is een module die een rijke set methoden biedt voor het doornemen, zoeken en manipuleren van verzamelingen — map, select, , , , en vele anderen. Arrays, hashes, ranges, en elke klasse die definieert, krijgen al deze methoden. Het staat centraal in Ruby's elegante, functionele dataverwerking.
reducefindgroup_byeach[1, 2, 3, 4, 5]
.select { |n| n.even? } # filter → [2, 4]
.map { |n| n * 10 } # transform → [20, 40]
[1, 2, 3, 4].reduce(0) { |sum, n| sum + n } # 10 — fold/accumulate (also .sum)
[1, 2, 3, 4].find { |n| n > 2 } # 3 — first match
[1, 2, 3, 4].all? { |n| n > 0 } # true
[1, 2, 3, 4].any? { |n| n > 3 } # true
[1, 2, 3, 4].count { |n| n.even? } # 2
[3, 1, 2].sort; [3, 1, 2].min; [3, 1, 2].max
[1, 2, 3].each_with_index { |val, i| ... }
words.group_by { |w| w.length } # group into a hash by a key
[1, 2, 3, 4].partition { |n| n.even? } # [[2,4], [1,3]] — split by condition
[1, 2, 3].each_slice(2).to_a # [[1,2],[3]] — chunks
Enumerable biedt tientallen expressieve methoden voor filteren, transformeren, aggregeren, zoeken, groeperen en chunken — die nagenoeg elke verzamelingsbewerking dekken en kunnen worden gekoppeld voor schone datapipelines.
{ a: 1, b: 2 }.select { |k, v| v > 1 } # hashes are Enumerable → { b: 2 }
(1..100).map { |n| n * 2 } # ranges are Enumerable
class TodoList
include Enumerable # mix in Enumerable...
def initialize = @items = []
def each(&block) # ...just define `each`...
@items.each(&block)
end
# ...and you get map, select, reduce, find, sort, etc. FOR FREE!
end
list = TodoList.new
list.select { |item| item.done? } # works! — Enumerable provides it via your `each`
Het elegante deel: include Enumerable en definieer alleen each, en je klasse krijgt alle Enumerable methoden (map, select, reduce, enz.) automatisch.
De Enumerable module staat centraal in Ruby's elegante, expressieve stijl van dataverwerking, en het begrijpen ervan is essentieel voor productieve, idiomatische Ruby.
Het biedt een rijke, uitgebreide set methoden (map, select, reduce, find, group_by, partition, all?, any?, en vele anderen) voor het werken met verzamelingen — en deze methoden, die je constant gebruikt op arrays, hashes en ranges, zijn wat Ruby's datamanipulatie zo beknopt en leesbaar maakt (het koppelen van expressieve bewerkingen in plaats van het schrijven van uitgebreide loops).
Het beheersen van Enumerable's methoden is essentieel voor het schrijven van vloeiende, functionaalstijl Ruby — zo filter, transformeer, aggregeer, zoek en groepeer je data elegant.
Bovendien kun je met een belangrijk en karakteristiek Ruby-kenmerk je eigen klassen Enumerable maken: door include Enumerable toe te voegen en alleen de each methode te definiëren, krijgt je klasse automatisch alle Enumerable methoden (map, select, reduce, enz.) — een krachtig voorbeeld van Ruby's mixin-ontwerp en een praktisch hulpmiddel voor het bouwen van aangepaste verzamelingsachtige klassen die zich als arrays gedragen.
Het begrijpen van Enumerable — de rijkdom aan methoden (de basis van Ruby's expressieve dataverwerking), dat arrays/hashes/ranges dit allemaal bevatten, en hoe je aangepaste klassen Enumerable maakt door each te definiëren — is belangrijk, veel toegepast kennis dat centraal staat in het schrijven van idiomatische Ruby.
Daarom dat dataverwerking met Enumerable methoden alomtegenwoordig is in Ruby (en Rails), en omdat het include Enumerable + each patroon een elegant voorbeeld is van Ruby's mixin-kracht, is het beheersen van Enumerable fundamenteel voor effectieve, idiomatische Ruby-ontwikkeling en een veelvoorkomend onderwerp dat vloeiendheid in het gebruik van de expressieve verzamelingsafhandeling van de taal weerspiegelt.