methods में yield कैसे काम करता है?

Question

Accepted Answer

**`yield`** किसी method को पास किए गए **block** को call करता है — यह नियंत्रण को block में स्थानांतरित करता है, वैकल्पिक रूप से इसे values पास करता है, फिर method को फिर से शुरू करता है। यही तरीका है जिससे methods उन्हें दिए गए blocks को invoke करते हैं, और Ruby के iteration और कई elegant patterns के पीछे का तंत्र है।

## Basic yield — call the given block

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

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

जब एक method `yield` call करता है, तो यह उस block को चलाता है जो इसे पास किया गया था (`{ }` या `do...end` में)। method नियंत्रित करता है कि block *कब* (और कितनी बार) चलता है।

## yield with arguments — pass values to the block

```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)` block के parameters (`|key, value|`) को values पास करता है — यही तरीका है जिससे iteration methods प्रत्येक element को block को देते हैं।

## Implementing iteration with 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 के iteration methods (`each`, `map`, आदि) अंदरूनी तौर पर कैसे काम करते हैं — वे प्रत्येक element को block को `yield` करते हैं।

## block_given? and capturing the block

```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?` जाँचता है कि क्या एक block पास किया गया था (एक `LocalJumpError` से बचते हुए), और `&block` block को एक Proc object के रूप में capture करता है जिसे आप store या आगे पास कर सकते हैं।

## यह क्यों महत्वपूर्ण है

`yield` को समझना महत्वपूर्ण Ruby ज्ञान है — यह वह तंत्र है जिससे methods blocks को invoke करते हैं, जो Ruby के विशिष्ट iteration और कई elegant patterns का आधार है, इसलिए इसे समझना यह प्रकाशित करता है कि Ruby का अधिकांश भाग वास्तव में कैसे काम करता है। `yield` किसी method को पास किए गए block को call करता है (नियंत्रण को इसमें स्थानांतरित करते हुए, वैकल्पिक रूप से values पास करते हुए), जो ठीक वही है जैसे Ruby के iteration methods (`each`, `map`, `select`) अंदरूनी तौर पर काम करते हैं — वे प्रत्येक element को block को `yield` करते हैं।

इसे समझना Ruby के block-based iteration को रहस्योद्घाटित करता है और आपको **अपने खुद के methods लिखने देता है जो blocks स्वीकार करते हैं** — अभिव्यंजक APIs, custom iterators, resource-management methods (एक block के चारों ओर setup/teardown), और DSLs बनाने के लिए एक शक्तिशाली क्षमता।

`yield` (block को call करना, इसे arguments पास करना), `block_given?` (सुरक्षित रूप से जाँचना कि क्या एक block पास किया गया था, errors से बचना), और `&block` (block को एक Proc के रूप में स्पष्ट रूप से capture करना) को जानना यह समझने के लिए कि Ruby के iteration और block-accepting methods कैसे काम करते हैं और अपने खुद के block-based methods लिखने दोनों के लिए महत्वपूर्ण है।

चूँकि blocks Ruby के केंद्र में हैं और `yield` वह तरीका है जिससे methods उनका उपयोग करते हैं, `yield` को समझना Ruby की सबसे विशिष्ट विशेषता (blocks) की आपकी समझ को गहरा करता है और आपको उस प्रकार के elegant, block-accepting methods लिखने में सक्षम बनाता है जो Ruby को अभिव्यंजक बनाते हैं — साफ़ APIs बनाने के लिए एक मूल्यवान कौशल और एक आम interview विषय जो इस बात की समझ को दर्शाता है कि Ruby का block तंत्र वास्तव में अंदरूनी तौर पर कैसे कार्य करता है।