yield chama o bloco passado para um método — ele transfere o controle para o bloco, opcionalmente passando valores a ele, e então retoma o método. É como os métodos invocam os blocos dados a eles, e o mecanismo por trás da iteração do Ruby e de muitos padrões elegantes.
puts
puts
greet { puts }
Quando um método chama yield, ele executa o bloco que foi passado a ele (em { } ou do...end). O método controla quando (e quantas vezes) o bloco é executado.
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 valores para os parâmetros do bloco (|key, value|) — é assim que os métodos de iteração fornecem cada elemento ao bloco.
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!
Isso mostra como os métodos de iteração do Ruby (each, map, etc.) funcionam internamente — eles yield cada elemento para o bloco.
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? verifica se um bloco foi passado (evitando um LocalJumpError), e &block captura o bloco como um objeto Proc que você pode armazenar ou passar adiante.
Entender yield é conhecimento importante do Ruby — é o mecanismo por trás de como os métodos invocam blocos, que sustenta a iteração característica do Ruby e muitos padrões elegantes, então compreendê-lo ilumina como grande parte do Ruby realmente funciona. yield chama o bloco passado para um método (transferindo controle a ele, opcionalmente passando valores), que é precisamente como os métodos de iteração do Ruby (each, map, select) funcionam internamente — eles yield cada elemento para o bloco.
Entender isso desmistifica a iteração baseada em blocos do Ruby e permite que você escreva seus próprios métodos que aceitam blocos — uma capacidade poderosa para criar APIs expressivas, iteradores customizados, métodos de gerenciamento de recursos (setup/teardown em torno de um bloco), e DSLs.
Conhecer yield (chamar o bloco, passar argumentos a ele), block_given? (verificar com segurança se um bloco foi passado, evitando erros), e &block (capturar explicitamente o bloco como um Proc) é importante tanto para entender como a iteração e os métodos que aceitam blocos do Ruby funcionam quanto para escrever seus próprios métodos baseados em blocos.
Já que blocos são centrais no Ruby e yield é como os métodos os usam, compreender yield aprofunda sua compreensão da característica mais distintiva do Ruby (blocos) e permite que você escreva o tipo de métodos elegantes que aceitam blocos e tornam o Ruby expressivo — uma habilidade valiosa para construir APIs limpas e um tópico comum em entrevistas que reflete a compreensão de como o mecanismo de blocos do Ruby realmente funciona nos bastidores.