हे तीन मार्ग आहेत ज्याद्वारे Ruby कोडचे तुकडे डेटा म्हणून हाताळते. एक block हा एक method ला पास केला जातो (object नाही); एक Proc आणि एक lambda हे objects आहेत जे एक block ला wrap करतात (callable, storable). Procs आणि lambdas argument checking आणि 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 हा कोड आहे जो method ला पास केला जातो ({ } किंवा do...end मध्ये) — हा एक स्वतंत्र object नाही जो तुम्ही store करू शकता; हा 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 आणि lambdas एक block ला object मध्ये wrap करतात जो तुम्ही variables ला assign करू शकता, चारपास पास करू शकता, आणि नंतर call करू शकता (.call) — reusable वर्तन store करण्यासाठी उपयोगी.
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
सर्वात महत्वाचा फरक: एक lambda method प्रमाणे वर्तन करतो (strict arguments, return फक्त lambda तून बाहेर येते), तर एक proc अधिक lenient असतो (argument mismatches दुर्लक्ष करते, आणि return enclosing method तून बाहेर येतो — जे आश्चर्यकारक वर्तन होऊ शकते). Lambdas सामान्यतः अधिक पसंद केले जातात त्यांच्या method-like, predictable वर्तनासाठी.
Blocks, procs, आणि lambdas समजून घेणे — आणि विशेषतः त्यांचे फरक — महत्वाचे Ruby ज्ञान आहे जे Ruby कोडचे डेटा म्हणून कसे हाताळते याचे खोल समज दर्शवते. Blocks सर्वात सामान्य आहेत (iteration आणि callbacks साठी methods ला पास केले जातात — Ruby चे हस्ताक्षर feature), तर procs आणि lambdas blocks ला storable, reusable objects मध्ये रूपांतरित करतात जा तुम्ही variables ला assign करू शकता, चारपास पास करू शकता, आणि नंतर call करू शकता (वर्तन store करण्यासाठी, functional patterns build करण्यासाठी, आणि callbacks values म्हणून पास करण्यासाठी उपयोगी).
procs आणि lambdas यांचे मुख्य फरक सूक्ष्म परंतु महत्वाचे आहेत आणि एक वारंवार interview topic आहे: argument checking (lambdas methods प्रमाणे strict आहेत, procs lenient आहेत) आणि विशेषतः return वर्तन (एक lambda चा return फक्त lambda तून बाहेर येतो, तर एक proc चा return enclosing method तून बाहेर येतो — जे आश्चर्यकारक, debug करण्यास कठीण वर्तन होऊ शकते).
हे फरक समजून घेणे — की एक lambda method प्रमाणे वर्तन करतो (strict, predictable, localized return सह) तर एक proc lenient असतो आश्चर्यकारक return semantics सह — हे त्यांचा योग्य वापर करण्यासाठी महत्वाचे आहे आणि lambdas अधिक पसंद करण्याची सामान्य शिफारस त्यांच्या predictable, method-like वर्तनासाठी.
Blocks रोज Ruby असतात आणि procs/lambdas storable callbacks आणि functional patterns साठी वापरले जातात, सर्व तीन समजून घेणे (विशेषतः proc-vs-lambda return आणि argument फरक) Ruby ज्ञान दर्शवते, proc-return gotcha टाळण्यास मदत करते, आणि एक classic interview topic आहे जे developers वेगळे करते जे Ruby च्या कोडचे objects म्हणून हाताळण्याचे true समज करतात.