Kako funkcionira yield u metodama?

Question

IT Interview Practice · Accepted Answer

**`yield`** poziva **blok** proslijeđen metodi — prenosi kontrolu bloku, opciono proslijeđujući vrijednosti, pa zatim nastavlja metodu. To je način na koji metode pozivaju blokove dane im, i mehanizam iza Ruby iteracije i mnogih elegantnih uzoraka.

## Osnovni yield — pozovi dati blok

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

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

Kada metoda pozove `yield`, pokreće blok koji joj je proslijeđen (u `{ }` ili `do...end`). Metoda kontrolira *kad* (i koliko puta) se blok pokreće.

## yield s argumentima — prosljeđi vrijednosti 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)` prosljeđuje vrijednosti parametrima bloka (`|key, value|`) — to je način na koji metode iteracije daju svaki element bloku.

## Implementiranje iteracije 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!
```

Ovo pokazuje kako Ruby-jeve metode iteracije (`each`, `map`, itd.) funkcioniraju interno — oni `yield` svaki element bloku.

## block_given? i hvatanje bloka

```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?` provjerava je li proslijeđen blok (izbjegavajući `LocalJumpError`), a `&block` hvata blok kao Proc objekt koji možeš pohraniti ili proslijediti dalje.

## Zašto je to važno

Razumijevanje `yield` je važno Ruby znanje — to je mehanizam iza kako metode pozivaju blokove, što je temelj Ruby-jeve karakteristične iteracije i mnogih elegantnuh uzoraka, pa razumijevanje toga objašnjava kako većina Ruby-ja zapravo funkcionira. `yield` poziva blok proslijeđen metodi (prenoseći kontrolu tom bloku, opciono proslijeđujući vrijednosti), što je upravo kako Ruby-jeve metode iteracije (`each`, `map`, `select`) funkcioniraju interno — oni `yield` svaki element bloku.

Razumijevanje ovoga demistificira Ruby-jevu iteraciju temeljenu na blokovima i omogućuje ti da **napišeš svoje metode koje prihvaćaju blokove** — moćna mogućnost za stvaranje izražajnih API-ja, prilagođenih iteratora, metoda upravljanja resursima (postavljanje/rušenje oko bloka) i DSL-a.

Znanje `yield` (pozivanje bloka, proslijeđivanje argumenata bloku), `block_given?` (sigurna provjera je li proslijeđen blok, izbjegavajući greške) i `&block` (eksplicitno hvatanje bloka kao Proc) je važno za razumijevanje kako Ruby-jeve metode iteracije i primanja blokova funkcioniraju i za pisanje vlastitih metoda temeljenih na blokovima.

Budući da su blokovi centralni za Ruby i `yield` je način na koji metode ih koriste, razumijevanje `yield` produbljuje tvoje shvaćanje Ruby-jeve najznačajnije značajke (blokovi) i omogućuje ti da napišeš vrstu elegantnuh metoda prihvaćanja blokova koji čine Ruby izražajnim — vrijedna vještina za izgradnju čistih API-ja i čest intervju-ski topik koji odražava razumijevanje kako mehanizam bloka Ruby-ja zapravo funkcionira ispod maske.

Osnovni yield — pozovi dati blok

yield s argumentima — prosljeđi vrijednosti bloku

Implementiranje iteracije s yield

block_given? i hvatanje bloka

Zašto je to važno

Povezana pitanja