Is iad seo trí bhealach a bhíonn ag Ruby chun bloic chóid a láimhseáil mar shonraí. Block a bhíonn ar iontráil ag modh (ní rud is ea é); Proc agus lambda ná rudaí a bhíonn ina bhfoluain thart ar bhloic (inghairte, inchomhlánaigh). Bíonn difríochtaí beaga ann idir Procs agus lambdas maidir le seiceáil argóintí agus iompar 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
Is é block an cód a bhíonn ar iontráil ag modh (in { } nó do...end) — ní rud neamhspleách is ea a bhíonn ann ar féad a stóráil; bíonn sé ceangailte don ghlaoch modh.
# 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
Bíonn procs agus lambdas ina bhfoluain thart ar bhloic i rud ar féad a shannú do athróga, a rá timpeall, agus a ghlaoch níos déanach (.call) — úsáideach do stóráil iompraíochta inúsáidte.
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
An difríocht is tábhachtaí: iompar cosúil le modh atá i lambda (argóintí déine, return ag imeall an lambda amháin), agus proc níos soirbhealacha (ficheall ar mheasúchán argóinte, agus return ag imeall an mhodh timpeall — rud a d'fhéadfadh iompar iontas a chur ar fáil). Lambdas a bhíonn níos fearr i gcoitinne dá ngoil cosúil le modh, intuigthe.
Bheith do thuiscint ar blocks, procs, agus lambdas — agus go háirithe ar na difríochtaí — tábhachtach do eolas Ruby a léiríonn breis tuisceana ar conas a bhíonn Ruby ag láimhseáil chóid mar shonraí. Blocks an ceann is coitianta (ar iontráil ag modhanna do athrú agus coinníoil — gné shíniúil Ruby), cé go procs agus lambdas a bhíonn ag athrú bloic i rudaí inchomhlánaigh, inúsáidte ar féad a shannadh do athróga, a rá timpeall, agus a ghlaoch níos déanai (úsáideach do stóráil iompraíochta, patrúin fheidhmiúla a thógáil, agus coinníoil a rá mar luachanna).
Bíonn na príomhdhifríochtaí idir procs agus lambdas beag ach tábhachtach agus ábhar comhdhéile agus agallamh: seiceáil argóinte (lambdas a bhíonn déine ar nós modhanna, procs a bhíonn soirbhealacha) agus go háirithe iompar return (ag imeall an lambda amháin atá return i lambda, cé go bhíonn return proc ag imeall an mhodh timpeall — rud a d'fhéadfadh iompar iontas, deacair-a-dhíchur a chur ar fáil).
Bheith do thuiscint ar na déanmhainní seo — go bhfuil lambda iompar cosúil le modh (déine, intuigthe, le toradh logánta) agus proc níos soirbhealacha le hiompar iontas return — tábhachtach do úsáid a dhéanamh ar an gceart agus don toradh coitianta a bhíonn ann ar lambdas a roghnú dá ngoil intuigthe, nós modhanna.
Cé go bhíonn blocks gach lá Ruby agus procs/lambdas a bhíonn úsáidte do choinníoil inchomhlánaigh agus patrúin fheidhmiúla, beith tuisceana ar na trí (go háirithe ar an proc-le-lambda return agus difríochtaí argóinte) a léiríonn eolas soladach Ruby, cabhrú a dhéanamh ar an proc-return gotcha a sheachaint, agus a bhíonn ina spréachta clasaiceach agus a bhíonn a léiríonn forbróirí a bhíonn a thuiscint i ndáiríre ar conas a bhíonn Ruby ag láimhseáil chóid mar rudaí.