Hizi ni njia tatu Ruby inavyoshughulikia vipande vya msimbo kama data. Block hupitishwa kwa method (si object); Proc na lambda ni objects zinazofunga block (zinazoitwa, zinazohifadhika). Procs na lambdas zinatofautiana kidogo katika argument checking na tabia ya 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 ni msimbo unaopitishwa kwa method (katika { } au do...end) — si object inayojitegemea unayoweza kuhifadhi; imefungwa kwa method call.
# 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 na lambdas hufunga block ndani ya object unayoweza kuipa variables, kupitisha pande zote, na kuiita baadaye (.call) — yenye manufaa kwa kuhifadhi tabia inayoweza kutumika tena.
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
Tofauti muhimu zaidi: lambda hutenda kama method (arguments strict, return huondoka lambda tu), ilhali proc ni laini zaidi (hupuuza kutolingana kwa arguments, na return huondoka enclosing method — ambayo inaweza kushtua). Lambdas kwa kawaida hupendelewa kwa tabia yao ya kifani-method, inayotabirika.
Kuelewa blocks, procs, na lambdas — na hasa tofauti zao — ni maarifa muhimu ya Ruby yanayoonyesha uelewa wa kina wa jinsi Ruby inavyoshughulikia msimbo kama data. Blocks ni za kawaida zaidi (zinazopitishwa kwa methods kwa iteration na callbacks — kipengele cha saini cha Ruby), ilhali procs na lambdas hugeuza blocks kuwa objects zinazohifadhika, zinazoweza kutumika tena unazoweza kuzipa variables, kuzipitisha pande zote, na kuziita baadaye (yenye manufaa kwa kuhifadhi tabia, kujenga patterns za functional, na kupitisha callbacks kama values).
Tofauti kuu kati ya procs na lambdas ni za hila lakini muhimu na mada ya mahojiano ya mara kwa mara: argument checking (lambdas ni strict kama methods, procs ni laini) na hasa tabia ya return (return ya lambda huondoka lambda tu, ilhali return ya proc huondoka enclosing method — ambayo inaweza kusababisha tabia ya kushtua, ngumu kutatua bugs).
Kuelewa tofauti hizi — kwamba lambda hutenda kama method (strict, inayotabirika, ikiwa na return iliyo localized) ilhali proc ni laini zaidi yenye return semantics za kushtua — ni muhimu kwa kuzitumia kwa usahihi na kwa pendekezo la kawaida la kupendelea lambdas kwa tabia yao inayotabirika, ya kifani-method.
Ingawa blocks ni Ruby ya kila siku na procs/lambdas hutumika kwa callbacks zinazohifadhika na patterns za functional, kuelewa zote tatu (hasa tofauti za proc-dhidi-ya-lambda za return na arguments) huonyesha maarifa imara ya Ruby, hukusaidia kuepuka tatizo la proc-return, na ni mada ya mahojiano ya kawaida inayotofautisha wendelezaji wanaoelewa kweli ushughulikiaji wa Ruby wa msimbo kama objects.