இவை மூன்று வழிகள் Ruby குறியீடு தொகுதிகளை தரவாக கையாளுகிறது. block என்பது ஒரு method க்கு அனுப்பப்படுவது (ஒரு object அல்ல); Proc மற்றும் lambda ஆகியவை ஒரு block ஐ wrap செய்யும் objects (callable, storable). Procs மற்றும் lambdas வாதங்கள் சரிபார்ப்பு மற்றும் 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 இல்) — இது ஒரு standalone object அல்ல நீங்கள் சேமிக்க முடியாது; இது 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 behavior சேமிப்பதற்கு பயனுள்ளதாக உள்ளது.
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 போல செயல்படுகிறது (கடுமையான வாதங்கள், return lambda ஐ மட்டும் வெளியேற்றுகிறது), சாதாரண proc மிகவும் சாதாரணமாக (வாத mismatch ஐ புறக்கணிக்கிறது, மற்றும் return enclosing method ஐ வெளியேற்றுகிறது — இது ஆச்சரியகரமான நடத்தை ஏற்படலாம்). Lambdas பொதுவாக விரும்பப்படுகின்றன அவற்றின் method-போல, முன்கணிப்பு செய்யக்கூடிய நடத்தைக்கு.
Blocks, procs, மற்றும் lambdas ஐ புரிந்துகொள்ளுதல் — மற்றும் குறிப்பாக அவற்றின் வேறுபாடுகள் — முக்கியமான Ruby அறிவு இது Ruby குறியீடு தரவாக எவ்வாறு கையாளுகிறது என்பதற்கு ஆழமான புரிதல் பிரதிபலிக்கிறது. Blocks மிகவும் பொதுவானவை (iteration மற்றும் callbacks க்கு methods க்கு அனுப்பப்படுவது — Ruby இன் signature feature), சாதாரண procs மற்றும் lambdas blocks ஐ storable, reusable objects க்கு திருப்புகின்றன நீங்கள் variables க்கு assign செய்யலாம், சுற்றி அனுப்பலாம், மற்றும் பின்னர் call செய்யலாம் (behavior சேமிப்பதற்கு, functional patterns கட்டமைப்பதற்கு, மற்றும் callbacks மதிப்புகளாக அனுப்புவதற்கு பயனுள்ளதாக உள்ளது).
procs மற்றும் lambdas க்கு இடையே உள்ள முக்கிய வேறுபாடுகள் நுணுக்கமாக உள்ளது ஆனால் முக்கியமாக உள்ளது மற்றும் ஒரு அடிக்கடி interview topic: வாத checking (lambdas methods போல கடுமையாக உள்ளது, procs சாதாரணமாக உள்ளது) மற்றும் குறிப்பாக return நடத்தை (ஒரு lambda இன் return lambda ஐ மட்டும் வெளியேற்றுகிறது, சாதாரண ஒரு proc இன் return enclosing method ஐ வெளியேற்றுகிறது — இது ஆச்சரியகரமான, hard-to-debug நடத்தை ஏற்படலாம்).
இந்த வேறுபாடுகளை புரிந்துகொள்ளுதல் — ஒரு lambda ஒரு method போல செயல்படுகிறது (கடுமையான, முன்கணிப்பு செய்யக்கூடிய, localized return உடன்) சாதாரண proc சாধாரணமான, ஆச்சரியகரமான return semantics உடன் — அவற்றை சரியாக பயன்படுத்துவதற்கு முக்கியமாக உள்ளது மற்றும் lambdas விரும்பு அவற்றின் முன்கணிப்பு செய்யக்கூடிய, method-போல நடத்தைக்கு பொதுவான பரிந்துரைக்கு.
Blocks இரोज Ruby மற்றும் procs/lambdas storable callbacks மற்றும் functional patterns க்கு பயன்படுத்தப்படுகிறது, மூன்றையும் புரிந்துகொள்ளுதல் (குறிப்பாக proc-vs-lambda return மற்றும் வாத வேறுபாடுகள்) திட Ruby அறிவை பிரதிபலிக்கிறது, நீங்கள் proc-return gotcha தவிர்க்க உதவுகிறது, மற்றும் ஒரு classical interview topic developers Ruby இன் code as objects கையாளுவதை உண்மையாக புரிந்துகொள்ளும் வேறுபடுத்துகிறது.