yield chiama il block passato a un metodo — trasferisce il controllo al block, opzionalmente passando valori ad esso, quindi riprende l'esecuzione del metodo. È il modo in cui i metodi invocano i block forniti loro, e il meccanismo dietro l'iterazione di Ruby e molti pattern eleganti.
puts
puts
greet { puts }
Quando un metodo chiama yield, esegue il block che è stato passato ad esso (in { } o do...end). Il metodo controlla quando (e quante volte) il block viene eseguito.
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) passa valori ai parametri del block (|key, value|) — è così che i metodi di iterazione passano ogni elemento al block.
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!
Questo mostra come funzionano internamente i metodi di iterazione di Ruby (each, map, ecc.) — loro yield ogni elemento al block.
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? controlla se un block è stato passato (evitando un LocalJumpError), e &block cattura il block come oggetto Proc che puoi memorizzare o passare oltre.
Capire yield è una conoscenza importante di Ruby — è il meccanismo dietro il modo in cui i metodi invocano block, che sottende l'iterazione caratteristica di Ruby e molti pattern eleganti, quindi comprenderlo illumina come funziona davvero gran parte di Ruby. yield chiama il block passato a un metodo (trasferendo il controllo ad esso, opzionalmente passando valori), che è esattamente come operano internamente i metodi di iterazione di Ruby (each, map, select) — loro yield ogni elemento al block.
Capire questo demistifica l'iterazione basata su block di Ruby e ti permette di scrivere i tuoi metodi che accettano block — una capacità potente per creare API espressive, iteratori personalizzati, metodi di gestione risorse (setup/teardown attorno a un block), e DSL.
Conoscere yield (chiamare il block, passare argomenti ad esso), block_given? (controllare in modo sicuro se un block è stato passato, evitando errori), e &block (catturare esplicitamente il block come Proc) è importante sia per capire come funzionano i metodi di iterazione e che accettano block di Ruby sia per scrivere i tuoi metodi basati su block.
Poiché i block sono centrali in Ruby e yield è il modo in cui i metodi li usano, capire yield approfondisce la tua comprensione della caratteristica più distintiva di Ruby (i block) e ti permette di scrivere il tipo di metodi eleganti che accettano block che rendono Ruby espressivo — una competenza preziosa per costruire API pulite e un argomento frequente nei colloqui che riflette la comprensione di come il meccanismo dei block di Ruby effettivamente funziona sotto il cofano.