yield विधिहरूमा कसरी काम गर्दछ?

Question

Accepted Answer

**`yield`** विधिमा पास गरिएको **ब्लक** लाई कल गर्दछ — यसले नियन्त्रण ब्लकमा स्थानान्तरित गर्दछ, वैकल्पिकरूपमा यसलाई मानहरू पास गर्दछ, त्यसपछि विधि पुन: सुरु गर्दछ। यो विधिहरूले उनीहरूलाई दिइएको ब्लकहरू कसरी आह्वान गर्छ भन्ने तरिका हो, र Ruby को पुनरावृत्ति र धेरै सुरुचिपूर्ण प्याटर्नहरूको पछाडि रहेको संयन्त्र हो।

## आधारभूत yield — दिइएको ब्लकलाई कल गर्नुहोस्

```ruby
def greet
  puts "before"
  yield                    # calls the block passed to greet
  puts "after"
end

greet { puts "hello" }
# Output: before / hello / after
```

जब कुनै विधि `yield` लाई कल गर्दछ, यसले यसमा पास गरिएको ब्लक चलाउँदछ (`{ }` वा `do...end` मा)। विधिले नियन्त्रण गर्दछ *कहिले* (र कति पटक) ब्लक चल्दछ।

## yield तर्कहरूसहित — ब्लकलाई मानहरू पास गर्नुहोस्

```ruby
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|`) — यो कसरी पुनरावृत्ति विधिहरूले प्रत्येक तत्व ब्लकलाई दिन्छ।

## yield सहित पुनरावृत्ति गर्ने कार्यान्वयन

```ruby
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` गर्दछ।

## block_given? र ब्लक क्याप्चर गर्दै

```ruby
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 को ब्लक संयन्त्र वास्तवमा कसरी काम गर्दछ भन्ने कुरा को बोध प्रतिबिम्बित गर्दछ।