yield हे methods मध्ये कसे काम करते?

Question

Accepted Answer

**`yield`** एका method ला दिलेल्या **block** ला कॉल करते — हे control block ला transfer करते, choice से values pass करते, आणि नंतर method चालू ठेवते। हे तर methods ला दिलेल्या blocks invoke करण्याचा मार्ग आहे, आणि Ruby च्या iteration आणि अनेक elegant patterns मागील यंत्रणा आहे।

## Basic yield — दिलेला 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` कॉल करते, तेव्हा ते त्याला दिलेला block चालवते (`{ }` किंवा `do...end` मध्ये). Method नियंत्रण करते *कधी* (आणि किती वेळा) block चालू होईल.

## yield with arguments — block ला values pass करा

```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 pass करते — हेच कसे iteration methods प्रत्येक element block ला देते.

## yield सह iteration लागू करा

```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`, इत्यादी) अंतर्गत कसे काम करतात — ते block ला प्रत्येक element `yield` करतात.

## block_given? आणि block capture करणे

```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?` check करते की block pass झाला की नाही (एक `LocalJumpError` टाळण्यासाठी), आणि `&block` block ला एक Proc object म्हणून capture करते जो तुम्ही store किंवा pass करू शकता.

## हे महत्वाचे का आहे

`yield` समजून घेणे हे महत्वाचे Ruby ज्ञान आहे — हे mechanism आहे की कसे methods blocks invoke करतात, जे Ruby च्या signature iteration आणि अनेक elegant patterns ला support करते, म्हणून हे समजून घेतल्यास हे उजाळते की Ruby कसे प्रत्यक्षात काम करते. `yield` एका method ला दिलेला block कॉल करते (त्याला control transfer करते, choice से values pass करते), जे नक्की कसे Ruby च्या iteration methods (`each`, `map`, `select`) अंतर्गत operate करतात — ते block ला प्रत्येक element `yield` करतात.

हे समजून घेतल्यास Ruby च्या block-based iteration ला demystify करते आणि तुम्हाला **blocks स्वीकार करणारी स्वतःची methods लिहिण्याची क्षमता** देते — expressive APIs, custom iterators, resource-management methods (setup/teardown एका block च्या भोवती), आणि DSLs तयार करण्यासाठी शक्तिशाली क्षमता.

`yield` (block कॉल करणे, त्याला arguments pass करणे), `block_given?` (safely check करणे की block pass झाला की नाही, errors टाळणे), आणि `&block` (स्पष्टपणे block ला Proc म्हणून capture करणे) हे जाणून घेणे महत्वाचे आहे Ruby च्या iteration आणि block-accepting methods कसे काम करतात हे समजून घेण्यासाठी आणि स्वतःची block-based methods लिहिण्यासाठी.

कारण blocks Ruby ला केंद्रीय आहे आणि `yield` हा methods ला त्यांचा वापर करण्याचा मार्ग आहे, `yield` समजून घेतल्यास Ruby च्या सर्वात distinctive feature (blocks) साठी तुमचे समज गहन होते आणि तुम्हाला elegant, block-accepting methods लिहिण्यासाठी सक्षम करते जे Ruby expressiveness लाते — clean APIs तयार करण्यासाठी मूल्यवान skill आणि हे एक सामान्य interview topic आहे जे Ruby च्या block mechanism कसे अंतर्गत काम करते हे समजून घेतल्यास प्रतिबिंबित होते.