Dawn huma tliet modi kif Ruby tħandel ċunċi ta' kod bħala data. Block jintiela' lil metodu (mhux oġġett); Proc u lambda huma oġġetti li jgħalbu block (callable, storable). Procs u lambdas ivarjaw subtilment fil-verifikazzjoni tal-arguments u l-imġieba ta' 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
Block huwa l-kod intlaʿ lil metodu (f' { } jew do...end) — mhux oġġett standalone li tista' taħżen; huwa marbut mal-sejħa tal-metodu.
# 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 u lambdas igħalbu block f'oġġett li tista' tassenja lil varjabbli, tippassja madwar, u ċċara aktar tard (.call) — utli għaħżin imġieba reusable.
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
L-aktar differenza importanti: lambda iġib bħal metodu (arguments stretti, return joħroġ biss il-lambda), filwaqt li proc huwa aktar lenient (injorat mismatch tal-arguments, u return joħroġ il-metodu inkluż — li jista' jikkawża imġieba sorprendenti). Lambdas huma ġeneralment preferuti għall-imġiebahom simili għal metodu u prevedibili.
L-għarfien ta' blocks, procs, u lambdas — u speċjalment id-differenzi tagħhom — huwa għarfien Ruby importanti li jirrifletti għarfien aktar profond ta' kif Ruby tħandel kod bħala data. Blocks huma l-aktar komuni (intlaʿ lil metodi għall-iterazzjoni u callbacks — il-feature firma ta' Ruby), filwaqt li procs u lambdas ibiddlu blocks f'oġġetti storage u reusable li tista' tassenja lil varjabbli, tippassja madwar, u ċċara aktar tard (utli għaħżin imġieba, nibnu patterns funzjonali, u tippassja callbacks bħala valuri).
Id-differenzi ewlenin bejn procs u lambdas huma subtili imma importanti u topic ta' intervista frekwenti: verifikazzjoni tal-arguments (lambdas huma stretti bħal metodi, procs huma lenient) u speċjalment imġieba ta' return (il-return ta' lambda joħroġ biss il-lambda, filwaqt li r-return ta' proc joħroġ il-metodu inkluż — li jista' jikkawża imġieba sorprendenti, diffiċli biex tdibaċ).
L-għarfien ta' dawn id-distinzjonijiet — li lambda iġib bħal metodu (stretta, prevedibili, b'return lokalizat) filwaqt li proc huwa aktar lenient b'semantika ta' return sorprendenti — huwa importanti għal użuha korrettament u għall-rakkomandazzjoni komuni li tippreferenza lambdas għall-imġiebahom prevedibili u simili għal metodu.
Billi blocks huma Ruby ta' kuljum u procs/lambdas huma użati għal callbacks storage u patterns funzjonali, l-għarfien ta' tewl (speċjalment id-differenzi ta' return u argument ta' proc-vs-lambda) jirrifletti għarfien Ruby solidu, jgħinuk tindaqq il-proc-return gotcha, u huwa topic ta' intervista klassiku li jidifferenzja developers li taf verament kif Ruby tħandel kod bħala oġġetti.