ఇవి Ruby కోడ్ చంక్లను డేటాగా నిర్వహించే మూడు విధాలు. బ్లాక్ ఒక మెథడ్కు పాస్ చేయబడుతుంది (ఆబ్జెక్ట్ కాదు); Proc మరియు lambda ఒక బ్లాక్ను కప్పిపుచ్చుకున్న ఆబ్జెక్ట్లు (callable, storable). ప్రాక్లు మరియు లాంబ్డాలు 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
ఒక బ్లాక్ అనేది ఒక మెథడ్కు పాస్ చేయబడిన కోడ్ ({ } లేదా do...endలో) — ఇది మీరు నిల్వ చేయగల స్టాండ్అలోన్ ఆబ్జెక్ట్ కాదు; ఇది మెథడ్ కాల్కు సంబంధించినది.
# 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
ప్రాక్లు మరియు లాంబ్డాలు బ్లాక్ను ఆబ్జెక్ట్గా కప్పిపుచ్చుకుంటాయి, దానిని వేరియబల్లకు కేటాయించవచ్చు, చుట్టూ పంపవచ్చు, మరియు తరువాత కాల్ చేయవచ్చు (.call) — పునర్వినియోగ చేయదగిన ప్రవర్తనను నిల్వ చేయడానికి ఉపయోగకరంగా ఉంటుంది.
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 మెథడ్ వంటిగా ఆచరిస్తుంది (కఠినమైన arguments, return కేవలం lambda నుండి నిష్క్రమిస్తుంది), అయితే ఒక proc మరింత సూక్ష్మమైనది (argument mismatches నిర్లక్ష్యం చేస్తుంది, మరియు return enclosing method నుండి నిష్క్రమిస్తుంది — ఇది ఆశ్చర్యకరమైన ప్రవర్తనకు కారణం కాగలదు). Lambdas సాధారణంగా ఆమోదయోగ్యమైనవి వాటి మెథడ్-లాంటి, సూచించదగిన ప్రవర్తన కోసం.
బ్లాక్లు, ప్రాక్లు, మరియు లాంబ్డాలను అర్థం చేసుకోవడం — మరియు ముఖ్యంగా వాటి తేడాలను — Ruby కోడ్ను డేటాగా ఎలా నిర్వహిస్తుందో స심్మర్థ అవగాహన ప్రతిబింబించే ముఖ్యమైన Ruby జ్ఞానం. Blocks అత్యంత సాధారణమైనవి (iteration మరియు callbacks కోసం మెథడ్లకు పాస్ చేయబడతాయి — Ruby యొక్క సంతరహస్త సౌకర్యం), అయితే procs మరియు lambdas బ్లాక్లను నిల్వ చేసిన, పునర్వినియోగ చేయదగిన ఆబ్జెక్ట్లుగా మారుస్తాయి, మీరు వేరియబల్లకు కేటాయించవచ్చు, చుట్టూ పంపవచ్చు, మరియు తరువాత కాల్ చేయవచ్చు (ప్రవర్తనను నిల్వ చేయడానికి, functional patterns నిర్మించడానికి, మరియు callbacks ను విలువలుగా పంపడానికి ఉపయోగకరంగా ఉంటుంది).
Procs మరియు lambdas మధ్య కీ తేడాలు సూక్ష్మమైనవి కానీ ముఖ్యమైనవి మరియు ఒక సాధారణ interview విషయం: argument checking (lambdas మెథడ్ల వంటి కఠినమైనవి, procs సూక్ష్మమైనవి) మరియు ముఖ్యంగా return ప్రవర్తన (lambda యొక్క return కేవలం lambda నుండి నిష్క్రమిస్తుంది, అయితే proc యొక్క return enclosing method నుండి నిష్క్రమిస్తుంది — ఇది ఆశ్చర్యకరమైన, డీబగ్ చేయడానికి కష్టమైన ప్రవర్తనకు కారణం కాగలదు).
ఈ సూక్ష్మతలను అర్థం చేసుకోవడం — ఒక lambda మెథడ్ వంటిగా ఆచరిస్తుంది (కఠినమైన, సూచించదగిన, స్థానికీకృత return సহ) అయితే ఒక proc ఆశ్చర్యకరమైన return semantics తో సూక్ష్మమైనది — ఇది వాటిని సరిగ్గా ఉపయోగించడానికి ముఖ్యమైనది మరియు lambdas ను ఆమోదయోగ్యమైనవిగా సూచించే సాధారణ సిఫారసు కోసం సమర్థక, అవశ్య ఉంటుంది.
బ్లాక్లు రోజువారీ Ruby విషయమైనప్పటికీ procs/lambdas storable callbacks మరియు functional patterns కోసం ఉపయోగించబడతాయి, ఉన్నాయి మూడింటిని అర్థం చేసుకోవడం (ముఖ్యంగా proc-vs-lambda return మరియు argument తేడాలు) Ruby కోడ్ను ఆబ్జెక్ట్లుగా నిర్వహించడం గురించి బృందపు Ruby జ్ఞానాన్ని ప్రతిబింబించింది, proc-return gotcha తప్పించడానికి సహాయం చేస్తుంది, మరియు Ruby కోడ్ను ఆబ్జెక్ట్లుగా నిజంగా అర్థం చేసుకున్న డెవలపర్లను వేరు చేసే క్లాసిక్ interview విషయం.