yield மெதடுகளில் எப்படி வேலை செய்கிறது?

Question

Accepted Answer

**`yield`** மெதডுக்கு கொடுக்கப்பட்ட **block**ஐ அழைக்கிறது — இது control block க்கு மாற்றுகிறது, விரும்பினால் மதிப்புகளை அதற்கு கொடுக்கிறது, பிறகு மெதடுவை மீண்டும் தொடங்குகிறது. இது மெதடுக்கள் அவர்களுக்கு கொடுக்கப்பட்ட blocks ஐ எப்படி அழைக்குகிறது என்பது, மேலும் Ruby இன் iteration மற்றும் பல நேர்த்தியான patterns க்குப் பின்னணிக்கு உள்ள வழிமுறை.

## பாசிக் yield — கொடுக்கப்பட்ட block ஐ அழைக்கவும்

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

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

மெதடு `yield` ஐ அழைக்கும்போது, அதற்கு கொடுக்கப்பட்ட block ஐ இயக்குகிறது (`{ }` அல்லது `do...end` இல்). மெதடு *எப்போது* (மற்றும் எத்தனை முறை) block இயங்குகிறது என்பதைக் கட்டுப்படுத்துகிறது.

## yield மற்றும் arguments — 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|`) — iteration மெதடுக்கள் ஒவ்வொரு தனிமத்தையும் 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 மெதடுக்கள் (`each`, `map`, முதலியன) உள்ளுறையாக எப்படி வேலை செய்கிறது என்பதைக் காட்டுகிறது — அவை ஒவ்வொரு தனிமத்தையும் block க்கு `yield` செய்கிறது.

## block_given? மற்றும் 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 ஆக பிடிக்கிறது, அதை நீங்கள் சேமிக்கலாம் அல்லது மீண்டும் கொடுக்கலாம்.

## இது ஏன் முக்கியமாக உள்ளது

`yield` ஐ புரிந்துகொள்வது முக்கியமான Ruby அறிவு — இது மெதடுக்கள் blocks ஐ எப்படி அழைக்கிறது என்பதற்குப் பின்னணிக்கு உள்ள வழிமுறை, இது Ruby இன் signature iteration மற்றும் பல நேர்த்தியான patterns ஐ அடிப்படையாக கொண்டுள்ளது, எனவே இதை புரிந்துகொள்வது Ruby உண்மையில் எப்படி வேலை செய்கிறது என்பதை வெளிச்சம் போடுகிறது. `yield` மெதடுக்கு கொடுக்கப்பட்ட block ஐ அழைக்கிறது (control அதற்கு மாற்றி, விரும்பினால் மதிப்புகளை கொடுத்து), இது Ruby இன் iteration மெதடுக்கள் (`each`, `map`, `select`) உள்ளுறையாக எப்படி செயல்படுகிறது என்பதுவே — அவை ஒவ்வொரு தனிமத்தையும் block க்கு `yield` செய்கிறது.

இதை புரிந்துகொள்வது Ruby இன் block-based iteration ஐ தெளிவாக செய்கிறது மற்றும் நீங்கள் **blocks ஐ ஏற்க்கும் உங்களின் சொந்த மெதடுக்களை எழுதலாம்** — expressive APIs, custom iterators, resource-management மெதடுக்கள் (setup/teardown block க்கு சுற்றாக), மற்றும் DSLs ஐ உருவாக்க ஒரு சக்திவாய்ந்த திறன்.

`yield` ஐ அறிந்திருப்பது (block ஐ அழைப்பது, அதற்கு arguments ஐ கொடுப்பது), `block_given?` (safely check செய்ய ஒரு block கொடுக்கப்பட்டுள்ளதா, errors ஐ தவிர்க்க), மற்றும் `&block` (explicitly block ஐ Proc ஆக பிடிப்பது) Ruby இன் iteration மற்றும் block-accepting மெதடுக்கள் எப்படி வேலை செய்கிறது என்பதை புரிந்துகொள்ள மற்றும் உங்களின் சொந்த block-based மெதடுக்களை எழுத இரண்டுக்குமே முக்கியமாக உள்ளது.

blocks Ruby இன் மையம் என்பதும் `yield` அவை எப்படி மெதடுக்கள் அவர்களை பயன்படுத்துகிறது என்பதும் இருப்பதால், `yield` ஐ புரிந்துகொள்வது Ruby இன் மிக distinctive feature (blocks) ஐ பற்றிய உங்கள் புரிந்துணர்வை ஆழமாக செய்கிறது மற்றும் Ruby expressive ஆக்குக்கும் நேர்த்தியான, block-accepting மெதடுக்களை எழுதலாம் — clean APIs ஐ உருவாக்க மற்றும் Ruby இன் block mechanism உண்மையில் under the hood எப்படி செயல்படுகிறது என்பதைப் பிரதிபலிக்கும் புரிந்துணர்வுக்கான ஒரு பொதுவான நேர்காணல் topic ஆக இருக்கும் ஒரு மதிப்பான திறன்.