Hvordan fungerer yield i metoder?

Question

IT Interview Practice · Accepted Answer

**`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

```ruby
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

```ruby
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

```ruby
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 `yield`er hvert element til blokken.

## block_given? og opsamling af blokken

```ruby
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 `yield`er 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.

Grundlæggende yield — kald den givne blok

yield med argumenter — send værdier til blokken

Implementering af iteration med yield

block_given? og opsamling af blokken

Hvorfor det betyder noget

Relaterede spørgsmål