Hogyan működik a yield a metódusokban?

Question

Accepted Answer

**`yield`** meghívja a metódusnak átadott **blokkot** — átadja a vezérlést a blokknak, opcionálisan értékeket átadva neki, majd folytatja a metódust. Ez az a módszer, ahogyan a metódusok meghívják a számukra adott blokkokat, és ez a mechanizmusa a Ruby iterációjának és sok elegáns mintának.

## A yield alapja — a megadott blokk meghívása

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

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

Amikor egy metódus meghívja a `yield`-et, az futtatja azt a blokkot, amely átadva lett neki (`{ }` vagy `do...end` formában). A metódus az *amikor* (és hányszor) szabályozza, hogy a blokk futjon.

## yield argumentumokkal — értékek átadása a blokknak

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

A `yield(args)` értékeket ad át a blokk paramétereinek (`|key, value|`) — így adják az iterációs metódusok minden elemet a blokknak.

## Iteráció implementálása yield-del

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

Ez azt mutatja, hogy a Ruby iterációs metódusai (`each`, `map`, stb.) belsőleg hogyan működnek — `yield`-elnek minden elemet a blokknak.

## block_given? és a blokk rögzítése

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

A `block_given?` ellenőrzi, hogy blokk lett-e átadva (elkerülve a `LocalJumpError`-t), és a `&block` Proc objektumként rögzíti a blokkot, amelyet tárolni vagy továbbadni lehet.

## Miért fontos

A `yield` megértése fontos Ruby ismeret — ez az a mechanizmusa, ahogyan a metódusok meghívják a blokkokat, amely alapjait képezi a Ruby aláírás iterációjának és sok elegáns mintának, így a megértése világosságot hoz arra, hogy a Ruby nagyrészt hogyan működik. A `yield` meghívja a metódusnak átadott blokkot (vezérlést átadva neki, opcionálisan értékeket átadva), amely pontosan az, ahogyan a Ruby iterációs metódusai (`each`, `map`, `select`) belsőleg működnek — `yield`-elnek minden elemet a blokknak.

Ennek megértése feloldja a Ruby blokkos iterációjának titkát és lehetővé teszi, hogy **saját metódusokat írj, amelyek blokkokat fogadnak el** — egy erőteljes képesség expresszív API-k, egyéni iterátorok, erőforrás-menedzsment metódusok (felépítés/lebontás egy blokk körül) és DSL-ek létrehozásához.

A `yield` (a blokk meghívása, argumentumok átadása neki), a `block_given?` (biztonságosan ellenőrizve, hogy blokk lett-e átadva, kerülve a hibákat) és az `&block` (explicit módon a blokkot Proc-ként rögzítve) ismerete fontos mind a Ruby iterációjának és blokkot fogadó metódusainak megértéséhez, mind saját blokkos metódusok írásához.

Mivel a blokkok központiak a Ruby-ban és a `yield` az, ahogyan a metódusok használják őket, a `yield` megértése mélyíti a Ruby legjellegzetesebb tulajdonságának (blokkok) megértését és lehetővé teszi az olyan elegáns, blokkot fogadó metódusok írását, amelyek expresszívvá teszik a Ruby-t — értékes készség tiszta API-k építéséhez és egy gyakori interjúkérdés, amely a Ruby blokkos mechanizmusának tényleges működésének megértését tükrözi.