Jedná se o tři způsoby, jak Ruby zpracovává kusy kódu jako data. Blok je předán metodě (není objekt); Proc a lambda jsou objekty, které zabalují blok (jsou volatelné, skladovatelné). Procs a lambdas se jemně liší v kontrole argumentů a chování return.
[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
Blok je kód předaný metodě (v { } nebo do...end) — není to samostatný objekt, který byste si mohli uložit; je vázaný na volání metody.
# 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
Procs a lambdas zabalují blok do objektu, který si můžete přiřadit k proměnné, předat dále a volat později (.call) — užitečné pro ukládání znovupoužitelného chování.
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
Nejdůležitější rozdíl: lambda se chová jako metoda (přísné argumenty, return ukončí jen lambdu), zatímco proc je benevolentější (ignoruje nesoulad v argumentech a return ukončí nadřazenou metodu — což může způsobit překvapivé chování). Lambdas jsou obecně preferovány pro jejich metody-podobné, předvídatelné chování.
Porozumění blokům, procům a lambdas — a zejména jejich rozdílům — je důležitá znalost Ruby, která odráží hlubší pochopení toho, jak Ruby zpracovává kód jako data. Bloky jsou nejčastější (předávají se metodám pro iteraci a callbacks — Ruby vám to umožňuje), zatímco procs a lambdas přeměňují bloky na skladovatelné, znovupoužitelné objekty, které si můžete přiřadit k proměnné, předat dále a volat později (užitečné pro ukládání chování, vytváření funkčních vzorů a předávání callbacků jako hodnot).
Klíčové rozdíly mezi procs a lambdas jsou jemné, ale důležité a jsou to časté interviewové témata: kontrola argumentů (lambdas jsou přísné jako metody, procs jsou benevolentní) a zejména chování return (return lambdy ukončí jen lambdu, zatímco return procu ukončí nadřazenou metodu — což může způsobit překvapivé, těžko debugovatelné chování).
Porozumění těmto rozdílům — že lambda se chová jako metoda (přísná, předvídatelná, s lokalizovaným returnem), zatímco proc je benevolentší s překvapivou sémantikou returnu — je důležité pro jejich správné používání a pro časté doporučení preferovat lambdas pro jejich předvídatelné, metody-podobné chování.
Zatímco bloky jsou každodenní Ruby a procs/lambdas se používají pro skladovatelné callbacky a funkční vzory, porozumění všem třem (zejména rozdílům return a argumentů mezi procs a lambdas) odráží solidní znalost Ruby, pomáhá vám vyhnout se gotchám s procovým returnem a je to klasické interviewové téma, které odlišuje vývojáře, kteří opravdu rozumí tomu, jak Ruby zpracovává kód jako objekty.