Hvordan fungerer yield i metoder?

yield kalder blokken som blev givet til en metode — det overfører kontrollen til blokken, eventuelt med værdier til den, og genoptager derefter metoden. Det er sådan, metoder påkalder de blokke, der gives til dem, og mekanismen bag Rubys iteration og mange elegante mønstre.

Grundlæggende yield — kald den givne blok

def greet
  puts "before"
  yield                    # calls the block passed to greet
  puts "after"
end

greet { puts "hello" }
# Output: before / hello / after

Når en metode kalder yield, kører den den blok, der blev givet til den (i { } eller do...end). Metoden styrer hvornår (og hvor mange gange) blokken kører.

yield med argumenter — send værdier til blokken

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) sender værdier til blokens parametre (|key, value|) — det er sådan, iterationsmetoder giver hvert element til blokken.

Implementering af iteration med yield

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!

Dette viser, hvordan Rubys iterationsmetoder (each, map osv.) fungerer internt — de yielder hvert element til blokken.

block_given? og opsamling af blokken

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? kontrollerer, om en blok blev givet (og undgår en LocalJumpError), og &block opsamler blokken som et Proc-objekt, som du kan gemme eller videregive.

Hvorfor det betyder noget

At forstå yield er vigtig Ruby-viden — det er mekanismen bag, hvordan metoder påkalder blokke, som ligger til grund for Rubys karakteristiske iteration og mange elegante mønstre, så forståelse heraf belyser, hvordan meget af Ruby faktisk fungerer. yield kalder den blok, der blev givet til en metode (overfører kontrollen til den, eventuelt med værdier), hvilket er præcis, hvordan Rubys iterationsmetoder (each, map, select) fungerer internt — de yielder hvert element til blokken.

At forstå dette afmystificerer Rubys blok-baserede iteration og gør det muligt for dig at skrive dine egne metoder, der accepterer blokke — en kraftfuld mulighed for at skabe udtryksfulde API'er, brugerdefinerede iteratorer, ressourcestyring-metoder (opsætning/nedlukning omkring en blok) og DSL'er.

At kende yield (kalde blokken, sende argumenter til den), block_given? (sikkert kontrollere, om en blok blev givet, uden fejl) og &block (eksplicit opsamling af blokken som et Proc) er vigtig for både at forstå, hvordan Rubys iteration og blok-accepterende metoder fungerer, og for at skrive dine egne blok-baserede metoder.

Da blokke er centrale for Ruby og yield er, hvordan metoder bruger dem, uddyber forståelse af yield din forståelse af Rubys mest karakteristiske funktion (blokke) og giver dig mulighed for at skrive den slags elegante, blok-accepterende metoder, der gør Ruby udtryksfuldt — en værdifuld evne for at bygge rene API'er og et almindeligt interviewemne, der afspejler forståelse af, hvordan Rubys blok-mekanisme faktisk fungerer under motorhjelmen.