Jak funguje yield v metodách?

Question

Accepted Answer

**`yield`** volá **blok** předaný metodě — předá kontrolu bloku, volitelně mu předá hodnoty, a pak pokračuje v metodě. Je to způsob, jakým metody volají předané bloky, a mechanismus za Ruby iterací a mnoha elegantnými vzory.

## Základní yield — zavolá daný blok

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

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

Když metoda volá `yield`, spustí blok, který jí byl předán (v `{ }` nebo `do...end`). Metoda kontroluje *kdy* (a kolikrát) se blok spustí.

## yield s argumenty — předej hodnoty bloku

```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)` předá hodnoty parametrům bloku (`|key, value|`) — takto iterační metody předávají každý prvek bloku.

## Implementace iterace s 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!
```

To ukazuje, jak Ruby iterační metody (`each`, `map`, atd.) fungují interně — volají `yield` pro každý prvek do bloku.

## block_given? a zachycení bloku

```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?` zkontroluje, zda byl blok předán (aby se zabránilo `LocalJumpError`), a `&block` zachytí blok jako objekt Proc, který můžeš uložit nebo předat dál.

## Proč na tom záleží

Porozumění `yield` je důležité znalosti Ruby — je to mechanismus za tím, jak metody volají bloky, což je základ Ruby iterací a mnoha elegantních vzorů, takže pochopení toho osvětluje, jak funguje velká část Ruby. `yield` volá blok předaný metodě (převádí kontrolu na něj, volitelně předává hodnoty), což je přesně to, jak Ruby iterační metody (`each`, `map`, `select`) fungují interně — volají `yield` pro každý prvek do bloku.

Porozumění tomu demystifikuje Ruby iteraci na základě bloků a umožní ti **psát vlastní metody, které přijímají bloky** — silná schopnost pro vytváření expresivních API, vlastních iterátorů, metod pro správu zdrojů (setup/teardown okolo bloku) a DSL.

Znalost `yield` (volání bloku, předávání argumentů), `block_given?` (bezpečné ověření, zda byl blok předán, aby se zabránilo chybám) a `&block` (explicitní zachycení bloku jako Proc) je důležitá jak pro pochopení, jak fungují Ruby iterační metody a metody přijímající bloky, tak pro psaní vlastních metod založených na blocích.

Protože bloky jsou centrální pro Ruby a `yield` je způsob, jakým je metody používají, pochopení `yield` prohloubí tvé chápání nejcharakterističtější feature Ruby (bloky) a umožní ti psát druh elegantních metod přijímajících bloky, které činí Ruby expresivní — cenná dovednost pro budování čistých API a běžné téma na pohovorech, které odráží pochopení, jak mechanismus bloků v Ruby skutečně funguje pod pokličkou.