yield appelle le bloc passé à une méthode — il transfère le contrôle au bloc, en passant optionnellement des valeurs à celui-ci, puis reprend la méthode. C'est la façon dont les méthodes invoquent les blocs qui leur sont donnés, et le mécanisme derrière l'itération de Ruby et de nombreux patterns élégants.
puts
puts
greet { puts }
Quand une méthode appelle yield, elle exécute le bloc qui lui a été passé (dans { } ou do...end). La méthode contrôle quand (et combien de fois) le bloc s'exécute.
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) passe des valeurs aux paramètres du bloc (|key, value|) — c'est ainsi que les méthodes d'itération donnent chaque élément au bloc.
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!
Ceci montre comment les méthodes d'itération de Ruby (each, map, etc.) fonctionnent en interne — elles yield chaque élément au bloc.
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? vérifie si un bloc a été passé (évitant une LocalJumpError), et &block capture le bloc en tant qu'objet Proc que vous pouvez stocker ou transmettre.
Comprendre yield est une connaissance Ruby importante — c'est le mécanisme derrière la façon dont les méthodes invoquent les blocs, qui sous-tend l'itération signature de Ruby et de nombreux patterns élégants, donc la saisir illumine comment beaucoup de Ruby fonctionne réellement. yield appelle le bloc passé à une méthode (en transférant le contrôle à celui-ci, en passant optionnellement des valeurs), ce qui est précisément la façon dont les méthodes d'itération de Ruby (each, map, select) fonctionnent en interne — elles yield chaque élément au bloc.
Comprendre cela démystifie l'itération basée sur les blocs de Ruby et vous permet d'écrire vos propres méthodes qui acceptent les blocs — une capacité puissante pour créer des APIs expressives, des itérateurs personnalisés, des méthodes de gestion des ressources (setup/teardown autour d'un bloc), et des DSLs.
Connaître yield (appeler le bloc, passer des arguments à celui-ci), block_given? (vérifier de manière sûre si un bloc a été passé, en évitant les erreurs), et &block (capturer explicitement le bloc en tant que Proc) est important pour comprendre à la fois comment les méthodes d'itération et acceptant les blocs de Ruby fonctionnent et pour écrire vos propres méthodes basées sur les blocs.
Puisque les blocs sont centraux à Ruby et que yield est la façon dont les méthodes les utilisent, comprendre yield approfondit votre compréhension de la caractéristique la plus distinctive de Ruby (blocs) et vous permet d'écrire le type de méthodes élégantes acceptant les blocs qui rendent Ruby expressif — une compétence précieuse pour construire des APIs propres et un sujet d'entretien courant qui reflète la compréhension de comment le mécanisme de bloc de Ruby fonctionne réellement sous le capot.