Acestea sunt trei moduri în care Ruby gestionează bucăți de cod ca date. Un block este transmis unei metode (nu este un obiect); un Proc și un lambda sunt obiecte care înfășoară un block (callable, storable). Procs și lambdas diferă subtil în verificarea argumentelor și comportamentul 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
Un block este codul transmis unei metode (în { } sau do...end) — nu este un obiect standalone pe care îl poți stoca; este legat de apelul metodei.
# 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 și lambdas înfășoară un block într-un obiect pe care îl poți asigna variabilelor, transmite mai departe și apela mai târziu (.call) — util pentru stocarea comportamentului reutilizabil.
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
Cea mai importantă diferență: un lambda se comportă ca o metodă (argumente stricte, return iese doar din lambda), în timp ce un proc este mai permisiv (ignoră nepotrivirea argumentelor, iar return iese din metoda cuprindătoare — ceea ce poate cauza comportament surpriză). Lambdas sunt de obicei preferate pentru comportamentul lor asemănător unei metode, predictibil.
Înțelegerea blocks, procs și lambdas — și mai ales diferențele lor — este cunoștință Ruby importantă care reflectă o înțelegere mai profundă a modului în care Ruby gestionează codul ca date. Blocks sunt cele mai frecvente (transmise metodelor pentru iterație și callbacks — trăsătura semnării Ruby), în timp ce procs și lambdas transformă blocks în obiecte storable, reutilizabile pe care le poți asigna variabilelor, transmite mai departe și apela mai târziu (util pentru stocarea comportamentului, construirea modelelor funcționale și transmiterea callbacks-urilor ca valori).
Diferențele cheie dintre procs și lambdas sunt subtile dar importante și un subiect frecvent al interviurilor: verificarea argumentelor (lambdas sunt stricte ca metodele, procs sunt permisive) și mai ales comportamentul return (un return lambda iese doar din lambda, în timp ce un return proc iese din metoda cuprindătoare — ceea ce poate cauza comportament surpriză, greu de depanat).
Înțelegerea acestor distincții — că un lambda se comportă ca o metodă (strict, predictibil, cu return localizat) în timp ce un proc este mai permisiv cu semantică return surpriză — este importantă pentru a le folosi corect și pentru recomandarea comună de a prefera lambdas pentru comportamentul lor predictibil, asemănător unei metode.
Deși blocks sunt Ruby de zi cu zi și procs/lambdas sunt folosite pentru callbacks storable și modele funcționale, înțelegerea tuturor trei (mai ales diferențele proc-vs-lambda return și argumente) reflectă cunoștințe Ruby solide, te ajută să eviți gotcha-ul proc-return și este un subiect clasic de interviu care diferențiază dezvoltatorii care într-adevăr înțeleg gestionarea Ruby a codului ca obiecte.