Waɗannan su ne hanyoyi uku Ruby ke amfani da su don sarrafa guntun code azaman data. Block ƙwaɗo ce ga wata hanya (ba abject ba); Proc da lambda su ne abubuwa da suke rufe block (callable, storable). Procs da lambdas suna bambanta a hanya kaɗan game da dube arguments da halin 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 shi ne code da aka ƙwaɗa ga hanya (a cikin { } ko do...end) — ba shi abject mai tsarari wanda kake iya ajiye ba; yana ɗaure ga kiran hanya.
# 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 da lambdas suke rufe block cikin abject wanda kake iya sanya shi ga variables, tura kewaye, da kira daga gida (call) — mai amfani don ajiye halin aiki wanda za a sake amfani.
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
Bambancin mafi mahimmanci: lambda yana halin kamar hanya (duri arguments, return ya fita cikil lambda kawai), yayin da proc ya kasance mai sulhu (ya watsi da daidain arguments, da return ya fita hanya ta waje — wanda zai iya jawo hankali). Lambdas suna fi dacewa saboda halin su kamar hanya, na fahimtarwa.
Sanin blocks, procs, da lambdas — sannan sanin bambancin su musamman — mahimmancin Ruby ne da yake nuni da zurfafan fahimta ta yaya Ruby ke sarrafa code azaman data. Blocks su ne mafi yawan amfani (ƙwaɗo ga hanyoyi don iteration da callbacks — alamar Ruby ta musamman), yayin da procs da lambdas suke juya blocks zuwa abubuwa storable, wanda za a sake amfani wanda kake iya sanya su ga variables, tura kewaye, da kira daga gida (mai amfani don ajiye halin aiki, samuwa da functional patterns, da tura callbacks azaman ƙiyaye).
Bambancin mahimmanci tsakanin procs da lambdas suna kaɗan kuma mahimmanci kuma jiya-jiya a gida interviews: dube arguments (lambdas sun dure kamar hanyoyi, procs suna mai sulhu) kuma musamman halin return (lambda na return ya fita cikil lambda kawai, yayin da proc na return ya fita hanya ta waje — wanda zai iya jawo hankali, wahala-to-debug halin).
Sanin waɗannan bambancin — cewa lambda yana halin kamar hanya (dure, fahimtarwa, tare da localized return) yayin da proc ya kasance mai sulhu tare da halin return wanda ba a tsammani ba — mahimmanci ne don amfani su daidai kuma don shawara ta yau da kullun na fifitawa lambdas saboda halin su fahimtarwa, kamar hanya.
Yayin da blocks sune auni gida Ruby da procs/lambdas ana amfani su don callbacks storable da functional patterns, sanin duka uku (musamman bambancin return da arguments tsakanin proc-vs-lambda) yana nuni da mahimmancin Ruby ne, yana taimaka muka ɓa sanin proc-return gotcha, kuma shi ne jiya-jiya interview jiya da yake bambanta developers waɗanda suke ainihin fahimta Ruby's sarrafa code azaman abubuwa.