આ તीન રીતો છે જે Ruby કોડના ટુકડાઓને ડેટા તરીકે હેન્ડલ કરે છે. બ્લોક એક મેથડને પાસ કરવામાં આવે છે (ઑબ્જેક્ટ નથી); પ્રોક અને લેમ્બડા ઑબ્જેક્ટ છે જે બ્લોકને લપેટે છે (કૉલેબલ, સ્ટોરેબલ). પ્રોક્સ અને લેમ્બડાસ તર્ક ચેકિંગ અને 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
સૌથી મહત્વનો તફાવત: લેમ્બડા મેથડ જેવું વર્તે છે (કઠોર તર્કો, return માત્ર લેમ્બડાને બહાર નીકળે છે), જ્યારે પ્રોક વધુ નમ્ર છે (તર્ક બેમેલને અવગણે છે, અને return એનક્લોઝિંગ મેથડને બહાર નીકળે છે — જે આશ્ચર્યજનક વર્તણૂક કરી શકે છે). લેમ્બડાસ સામાન્ય રીતે પસંદ કરવામાં આવે છે તેમના મેથડ-જેવા, પ્રેડિક્ટેબલ વર્તણૂક માટે.
બ્લોક્સ, પ્રોક્સ અને લેમ્બડાસ સમજવું — અને ખાસ કરીને તેમના તફાવતો — મહત્વપૂર્ણ Ruby જ્ઞાન છે જે Ruby કોડને ડેટા તરીકે કેવી રીતે હેન્ડલ કરે છે તેની ઊંડી સમજણ પ્રતિબિંબિત કરે છે. બ્લોક્સ સૌથી સામાન્ય છે (ઇટરેશન અને કૉલબેક્સ માટે મેથડ્સને પાસ કરવામાં આવે છે — Ruby ની સિગ્નેચર ફીચર), જ્યારે પ્રોક્સ અને લેમ્બડાસ બ્લોક્સને સ્ટોરેબલ, રીયુઝેબલ ઑબ્જેક્ટ્સમાં ફેરવે છે જે તમે ચલોને અસાઇન કરી શકો, આસપાસ પાસ કરી શકો, અને પછીથી કૉલ કરી શકો (વર્તણૂક સ્ટોર કરવા માટે, ફંક્શનલ પેટર્નો બિલ્ડ કરવા માટે, અને કૉલબેક્સને મૂલ્યો તરીકે પાસ કરવા માટે ઉપયોગી).
પ્રોક્સ અને લેમ્બડાસ વચ્ચેના મુખ્ય તફાવતો સૂક્ષ્મ પણ મહત્વપૂર્ણ છે અને એક વારંવાર ઈન્ટરવ્યુ ટોપિક છે: તર્ક ચેકિંગ (લેમ્બડાસ મેથડ્સ જેવા કઠોર છે, પ્રોક્સ નમ્ર છે) અને ખાસ કરીને return વર્તણૂક (લેમ્બડાના return માત્ર લેમ્બડાને બહાર નીકળે છે, જ્યારે પ્રોકના return એનક્લોઝિંગ મેથડને બહાર નીકળે છે — જે આશ્ચર્યજનક, ડીબગ કરવાની મુશ્કેલ વર્તણૂક કરી શકે છે).
આ વિશિષ્ટતાઓ સમજવું — કે લેમ્બડા મેથડ જેવું વર્તે છે (કઠોર, પ્રેડિક્ટેબલ, લોકલાઇઝ્ડ રિટર્ન સાથે) જ્યારે પ્રોક આશ્ચર્યજનક રિટર્ન સેમાન્ટિક્સ સાથે વધુ નમ્ર છે — તેમને સાચીથી ઉપયોગ કરવા માટે અને લેમ્બડાસને પસંદ કરવાની સામાન્ય সિફारિશ માટે મહત્વપૂર્ણ છે તેમના પ્રેડિક્ટેબલ, મેથડ-જેવી વર્તણૂક માટે.
જ્યારે બ્લોક્સ રોજીંદા Ruby છે અને પ્રોક્સ/લેમ્બડાસ સ્ટોરેબલ કૉલબેક્સ અને ફંક્શનલ પેટર્નમાં ઉપયોગ કરવામાં આવે છે, તમામ ત્રણને સમજવું (ખાસ કરીને પ્રોક-vs-લેમ્બડા રિટર્ન અને તર્ક તફાવતો) ઠોસ Ruby જ્ઞાન પ્રતિબિંબિત કરે છે, તમને પ્રોક-રિટર્ન ગોચા ટાળવામાં મદદ કરે છે, અને એક ક્લાસિક ઈન્ટરવ્યુ ટોપિક છે જે ડેવલપર્સને અલગ પાડે છે જેઓ ખરેખર Ruby ની કોડ ઑબ્જેક્ટ તરીકે હેન્ડલિંગને સમજે છે.