ये तीन तरीके हैं जिनसे Ruby code के टुकड़ों को data के रूप में संभालता है। एक block किसी method को पास किया जाता है (object नहीं); एक Proc और एक lambda ऐसे objects हैं जो एक block को wrap करते हैं (callable, storable)। Procs और lambdas argument checking और return behavior में सूक्ष्म रूप से भिन्न होते हैं।
[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 वह code है जो किसी method को पास किया जाता है ({ } या do...end में) — यह एक standalone 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) — पुन: प्रयोज्य behavior को 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 से बाहर निकलता है — जो आश्चर्यजनक behavior का कारण बन सकता है)। Lambdas को आमतौर पर प्राथमिकता दी जाती है उनके method-जैसे, अनुमानित behavior के लिए।
blocks, procs, और lambdas को समझना — और विशेष रूप से उनके अंतरों को — महत्वपूर्ण Ruby ज्ञान है जो यह दर्शाता है कि Ruby code को data के रूप में कैसे संभालता है, इसकी गहरी समझ को दर्शाता है। Blocks सबसे आम हैं (iteration और callbacks के लिए methods को पास किए जाते हैं — Ruby की विशिष्ट विशेषता), जबकि procs और lambdas blocks को storable, पुन: प्रयोज्य objects में बदलते हैं जिन्हें आप variables को assign कर सकते हैं, इधर-उधर पास कर सकते हैं, और बाद में call कर सकते हैं (behavior को store करने, functional patterns बनाने, और callbacks को values के रूप में पास करने के लिए उपयोगी)।
procs और lambdas के बीच मुख्य अंतर सूक्ष्म लेकिन महत्वपूर्ण हैं और एक बार-बार आने वाला interview विषय हैं: argument checking (lambdas methods की तरह strict हैं, procs lenient हैं) और विशेष रूप से return behavior (एक lambda का return केवल lambda से बाहर निकलता है, जबकि एक proc का return enclosing method से बाहर निकलता है — जो आश्चर्यजनक, मुश्किल-से-debug behavior का कारण बन सकता है)।
इन अंतरों को समझना — कि एक lambda एक method की तरह व्यवहार करता है (strict, अनुमानित, localized return के साथ) जबकि एक proc आश्चर्यजनक return semantics के साथ अधिक lenient है — उन्हें सही ढंग से उपयोग करने और उनके अनुमानित, method-जैसे behavior के लिए lambdas को प्राथमिकता देने की आम सिफारिश के लिए महत्वपूर्ण है।
जबकि blocks रोज़मर्रा का Ruby है और procs/lambdas storable callbacks और functional patterns के लिए उपयोग होते हैं, तीनों को समझना (विशेष रूप से proc-बनाम-lambda return और argument अंतर) ठोस Ruby ज्ञान को दर्शाता है, आपको proc-return gotcha से बचने में मदद करता है, और एक classic interview विषय है जो उन developers को अलग करता है जो वास्तव में Ruby के code को objects के रूप में संभालने को समझते हैं।