yield roept het blok aan dat aan een methode is doorgegeven — het geeft controle over aan het blok, geeft optioneel waarden eraan door, en hervat vervolgens de methode. Het is hoe methoden de blokken die aan hen zijn gegeven aanroepen, en het mechanisme achter Ruby's iteratie en veel elegante patronen.
puts
puts
greet { puts }
Wanneer een methode yield aanroept, voert het het blok uit dat aan het is doorgegeven (in { } of do...end). De methode bepaalt wanneer (en hoe vaak) het blok wordt uitgevoerd.
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) geeft waarden door aan de parameters van het blok (|key, value|) — op deze manier geven iteratiemethoden elk element aan het blok.
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!
Dit toont hoe Ruby's iteratiemethoden (each, map, enz.) intern werken — zij yield elk element aan het blok.
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? controleert of een blok is doorgegeven (ter voorkoming van een LocalJumpError), en &block legt het blok vast als een Proc-object dat je kunt opslaan of doorgeven.
Het begrijpen van yield is belangrijk Ruby-kennis — het is het mechanisme achter hoe methoden blokken aanroepen, wat ten grondslag ligt aan Ruby's karakteristieke iteratie en veel elegante patronen, dus het ervan afweten verlicht hoe veel van Ruby eigenlijk werkt. yield roept het blok aan dat aan een methode is doorgegeven (geeft controle eraan over, geeft optioneel waarden door), wat precies is hoe Ruby's iteratiemethoden (each, map, select) intern werken — zij yield elk element aan het blok.
Het begrijpen hiervan maakt Ruby's blok-gebaseerde iteratie duidelijk en stelt je in staat om je eigen methoden te schrijven die blokken accepteren — een krachtig vermogen voor het creëren van expressieve API's, aangepaste iterators, resource-managementmethoden (setup/teardown rond een blok), en DSL's.
Het kennen van yield (het aanroepen van het blok, het doorgeven van argumenten eraan), block_given? (veilig controleren of een blok is doorgegeven, fouten vermijden), en &block (expliciet het blok als Proc vastleggen) is belangrijk zowel voor het begrijpen van hoe Ruby's iteratie en blok-accepterende methoden werken als voor het schrijven van je eigen blok-gebaseerde methoden.
Omdat blokken centraal staan in Ruby en yield is hoe methoden ze gebruiken, verdiept het begrijpen van yield je inzicht in Ruby's meest karakteristieke kenmerk (blokken) en stelt het je in staat om het soort elegante, blok-accepterende methoden te schrijven die Ruby expressief maken — een waardevolle vaardigheid voor het bouwen van schone API's en een veelvoorkomend interviewonderwerp dat inzicht weerspiegelt in hoe Ruby's blokmechanisme eigenlijk onder de motorkap functioneert.