yield ఎలా మెథడ్‌లలో పని చేస్తుంది?

Question

Accepted Answer

**`yield`** మెథడ్‌కు పాస్ చేయబడిన **block** ను కాల్ చేస్తుంది — ఇది కంట్రోల్‌ను బ్లాక్‌కు బదిలీ చేస్తుంది, ఐచ్ఛికంగా దానికి విలువలను పాస్ చేస్తుంది, ఆపై మెథడ్‌ను తిరిగి ప్రారంభిస్తుంది. ఇది మెథడ్‌ల ఎలా బ్లాక్‌లను ఇన్‌వోక్ చేయాలో నిర్ణయించే విధానం, మరియు 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 with arguments — బ్లాక్‌కు విలువలను పాస్ చేయండి

```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` (బ్లాక్‌ను కాల్ చేయడం, దానికు arguments పాస్ చేయడం), `block_given?` (బ్లాక్ పాస్ చేయబడిందో లేదో సురక్షితంగా తనిఖీ చేయడం, errors నుండి తప్పించుకోవడం), మరియు `&block` (స్పష్టంగా బ్లాక్‌ను Proc గా క్యాప్చర్ చేయడం) తెలుసుకోవడం Ruby యొక్క ఇటరేషన్ మరియు బ్లాక్-అంగీకరించే మెథడ్‌ల ఎలా పని చేస్తాయో అర్థం చేసుకోవటానికి మరియు మీ స్వంత బ్లాక్-ఆధారిత మెథడ్‌లను వ్రాయటానికి ముఖ్యమైనది.

Blocks Ruby కు కేంద్రీయమైనవి కాబట్టి `yield` మెథడ్‌లు వాటిని ఎలా ఉపయోగిస్తాయో, `yield` ను అర్థం చేసుకోవడం Ruby యొక్క అత్యంత విలక్షణమైన ఫీచర్ (blocks) పట్ల మీ గ్రహణాన్ని లోతుగా చేస్తుంది మరియు Ruby ను ఎక్సప్రెసివ్ చేసే ఎలిగ్యాంట్, బ్లాక్-అంగీకరించే మెథడ్‌లను వ్రాయటానికి మీను సక్షమ చేస్తుంది — క్లీన్ APIs నిర్మించటానికి విలువైన నైపుణ్యం మరియు Ruby యొక్క బ్లాక్ మెకానిజం నిజానికి కింద ఎలా పని చేస్తుందో అర్థం చేసుకోవటను ప్రతిబింబించే సాధారణ ఇంటర్‌వ్యూ విషయం.