Ezek három módja annak, hogy a Ruby kóddarabokat adatként kezeli. A block egy metódusnak átadott kód (nem objektum); a Proc és a lambda olyan objektumok, amelyek egy blokkot csomagolnak be (hívható, tárolható). A Procok és lambdák finoman különböznek az argumentum-ellenőrzés és a return viselkedésében.
[1, 2, 3].each { |n| puts n } # the { } is a block — passed to each
# a block is NOT an object; it's part of the method call, can't be stored in a variable directly
A blokk egy metódusnak átadott kód (a { } vagy do...end szintaxisban) — ez nem egy önálló objektum, amelyet tárolhatsz; a metódushíváshoz kötött.
# a Proc — a block turned into an object you can store and call
square = Proc.new { |x| x * x }
square.call(5) # 25
square.(5) # 25 (alternate call syntax)
# a lambda — also a callable object (a "stricter" Proc)
double = lambda { |x| x * 2 }
double = ->(x) { x * 2 } # the -> "stabby lambda" syntax
double.call(5) # 10
A procok és lambdák egy blokkot objektummá alakítanak, amelyet változókhoz rendelhetsz, átadozhatsz, és később meg tudsz hívni (.call) — hasznos az újrafelhasználható viselkedés tárolására.
1. ARGUMENT CHECKING:
lambda → STRICT: errors if wrong number of arguments (like a method)
proc → LENIENT: ignores extra args, fills missing with nil
2. RETURN behavior:
lambda → `return` returns from the LAMBDA (like a normal method)
proc → `return` returns from the ENCLOSING METHOD (can surprise you!)
def test_proc
p = Proc.new { return 10 }
p.call # returns from test_proc ENTIRELY → 10
return 20 # never reached!
end
def test_lambda
l = lambda { return 10 }
l.call # returns from the LAMBDA only → 10
return 20 # reached → test_lambda returns 20
end
A legfontosabb különbség: egy lambda úgy viselkedik, mint egy metódus (szigorú argumentumok, a return csak a lambdát fejezi be), míg egy proc többet enged meg (figyelmen kívül hagyja az argumentum eltéréseket, és a return a befoglaló metódusból lép ki — ami meglepő viselkedéshez vezethet). A lambdákat általában előnyösebbnek tartják az akár-metódushoz-hasonló, kiszámítható viselkedésük miatt.
A blokkok, procok és lambdák megértése — és különösen a különbségeik — fontos Ruby ismeret, amely tükrözi a mélyebb megértést arról, hogy a Ruby hogyan kezeli a kódot adatként. A blokkok a leggyakoribbak (metódusoknak átadott iterációhoz és visszahívásokhoz — a Ruby szignifikáns jellemzője), míg a procok és lambdák a blokkokat tárolható, újrafelhasználható objektumokká alakítják, amelyeket változókhoz rendelhetsz, átadozhatsz, és később meghívhatsz (hasznos a viselkedés tárolásához, funkcionális minták felépítéséhez és visszahívások értékekként való átadásához).
A procok és lambdák közötti kulcsfontosságú különbségek finomak, de fontosak, és gyakori interjúkérdés: argumentum-ellenőrzés (a lambdák szigorúak, mint a metódusok, a procok türelmesebbek) és különösen a return viselkedés (egy lambda return-je csak a lambdát fejezi be, míg egy proc return-je az befoglaló metódusból lép ki — ami meglepő, nehéz debuggolható viselkedéshez vezethet).
Annak megértése, hogy egy lambda úgy viselkedik, mint egy metódus (szigorú, kiszámítható, lokalizált return-nel), míg egy proc türelmes a meglepő return szemantikájával — fontos ezek helyes használatához, és a gyakori ajánláshoz, hogy a lambdákat előnyben részesítsd a kiszámítható, metódushoz-hasonló viselkedésük miatt.
Ha a blokkok a napi Ruby használat és a procok/lambdák a tárolható visszahívásokhoz és funkcionális mintákhoz használatosak, az összes három megértése (különösen a proc-vs-lambda return és argumentum különbségei) szilárd Ruby tudást tükröz, segít elkerülni a proc-return csapdát, és egy klasszikus interjúkérdés, amely megkülönbözteti azokat a fejlesztőket, akik valóban megértik a Ruby kódkezelésének objektumokként.