yield મેથડને આપવામાં આવેલ બ્લોકને કૉલ કરે છે — તે નિયંત્રણ બ્લોકને સ્થાનાંતરિત કરે છે, વૈકલ્પિક રીતે તેને મૂલ્યો પસાર કરે છે, અને પછી મેથડ ફરી શરૂ કરે છે. તે એ છે કે કેવી રીતે મેથડ્સ તેમને આપવામાં આવેલ બ્લોક્સને આમંત્રણ આપે છે, અને Ruby ના ઇટરેશન અને ઘણા સુંદર પેટર્નની પાછળની પદ્ધતિ છે.
puts
puts
greet { puts }
જ્યારે મેથડ yield કૉલ કરે છે, ત્યારે તે બ્લોક ચલાવે છે જે તેને આપવામાં આવ્યો હતો ({ } અથવા do...end માં). મેથડ નિયંત્રણ કરે છે ક્યારે (અને કેટલી વખત) બ્લોક ચલાય છે.
def each_pair
yield("a", 1) # pass values to the block's parameters
yield("b", 2)
end
each_pair { |key, value| puts "#{key}: #{value}" }
# Output: a: 1 / b: 2
yield(args) બ્લોકના પરિમાણો (|key, value|) ને મૂલ્યો પસાર કરે છે — આ એ છે કે કેવી રીતે ઇટરેશન મેથડ્સ દરેક તત્વ બ્લોકને આપે છે.
def my_each(array)
i = 0
while i < array.length
yield(array[i]) # yield each element to the block
i += 1
end
end
my_each([1, 2, 3]) { |n| puts n * 2 } # 2, 4, 6
# this is essentially how Array#each works internally!
તે બતાવે છે કે Ruby ના ઇટરેશન મેથડ્સ (each, map, વગેરે) આંતરિક રીતે કેવી રીતે કામ કરે છે — તેઓ બ્લોકને દરેક તત્વ yield કરે છે.
def maybe_yield
if block_given? # check whether a block was passed (avoid an error)
yield
else
"no block"
end
end
# explicitly capture the block as a parameter (with &)
def run(&block) # &block captures the block as a Proc object
block.call # call it explicitly
end
block_given? ચકાસે છે કે બ્લોક પસાર કરવામાં આવ્યો હતો કે નહીં (LocalJumpError ટાળવા માટે), અને &block બ્લોકને Proc ઓબ્જેક્ટ તરીકે કેપ્ચર કરે છે જે તમે સ્ટોર કરી શકો છો અથવા આગળ પસાર કરી શકો છો.
yield સમજવું મહત્વપૂર્ણ Ruby જ્ઞાન છે — તે એ પદ્ધતિ છે કે કેવી રીતે મેથડ્સ બ્લોક્સને આમંત્રણ આપે છે, જે Ruby ના સહી ઇટરેશન અને ઘણા સુંદર પેટર્નને આધાર આપે છે, તેથી તેને સમજવું પ્રકાશ પાડે છે કે Ruby ખરેખર કેવી રીતે કાર્ય કરે છે. yield મેથડને આપવામાં આવેલ બ્લોકને કૉલ કરે છે (તેને નિયંત્રણ સ્થાનાંતરિત કરે છે, વૈકલ્પિક રીતે મૂલ્યો પસાર કરે છે), જે બરાબર એ છે કે Ruby ના ઇટરેશન મેથડ્સ (each, map, select) આંતરિક રીતે કેવી રીતે કામ કરે છે — તેઓ બ્લોકને દરેક તત્વ yield કરે છે.
તે સમજવું Ruby ના બ્લોક-આધારિત ઇટરેશનને સ્પષ્ટ કરે છે અને તમને બ્લોક્સ સ્વીકારતા તમારા પોતાના મેથડ્સ લખવા દે છે — સુંદર APIs, કસ્ટમ ઇટરેટર્સ, સંસાધન-વ્યવસ્થાપન મેથડ્સ (બ્લોકની આસપાસ સેટআપ/ટિયરડાઉન), અને DSLs બનાવવા માટે શક્તિશાળી ક્ષમતા.
yield જાણવું (બ્લોક કૉલ કરવું, તેને દલીલો પસાર કરવી), block_given? (સુરક્ષિત રીતે ચકાસવું કે બ્લોક પસાર કરવામાં આવ્યો હતો કે નહીં, ભૂલો ટાળવી), અને &block (સ્પષ્ટ રીતે બ્લોકને Proc તરીકે કેપ્ચર કરવું) Ruby ના ઇટરેશન અને બ્લોક-સ્વીકારતા મેથડ્સ કેવી રીતે કાર્ય કરે છે તે સમજવા અને તમારા પોતાના બ્લોક-આધારિત મેથડ્સ લખવા બંને માટે મહત્વપૂર્ણ છે.
બ્લોક્સ Ruby માટે કેન્દ્રીય છે અને yield એ છે કે મેથડ્સ તેમનો ઉપયોગ કેવી રીતે કરે છે, yield સમજવું તમારા Ruby ના સૌથી અલગ લક્ષણ (બ્લોક્સ) ના પ્રતિ સમજણને ઊંડું કરે છે અને તમને તે પ્રકારના સુંદર, બ્લોક-સ્વીકારતા મેથડ્સ લખવા સક્ષમ કરે છે જે Ruby ને અભિવ્યક્તિશીલ બનાવે છે — સ્વચ્છ APIs બનાવવા માટે મૂલ્યવાન કૌશલ્ય અને તે એક સામાન્ય ઇન્ટરવ્યુ વિષય છે જે Ruby ના બ્લોક મિકેનિઝમ ખરેખર હૂડ હેઠળ કેવી રીતે કાર્ય કરે છે તે સમજણ પ્રતિબિંબિત કરે છે.