ਯੀਲਡ ਮੈਥਡਾਂ ਵਿੱਚ ਕਿਵੇਂ ਕਾਮ ਕਰਦਾ ਹੈ?

Question

Accepted Answer

**`yield`** ਮੈਥਡ ਨੂੰ ਪਾਸ ਕੀਤੇ ਗਏ **ਬਲਾਕ** ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ — ਇਹ ਕੰਟਰੋਲ ਨੂੰ ਬਲਾਕ ਤੱਕ ਟ੍ਰਾਂਸਫਰ ਕਰਦਾ ਹੈ, ਇੱਛਕ ਤੌਰ ਤੇ ਇਸ ਨੂੰ ਮੁੱਲ ਪਾਸ ਕਰਦੇ ਹੋਏ, ਫਿਰ ਮੈਥਡ ਨੂੰ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। ਇਹ ਉਹ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ ਮੈਥਡ ਉਨ੍ਹਾਂ ਬਲਾਕਾਂ ਨੂੰ ਇਨਵੋਕ ਕਰਦੇ ਹਨ ਜੋ ਉਨ੍ਹਾਂ ਨੂੰ ਦਿੱਤੇ ਗਏ ਹਨ, ਅਤੇ ਰੂਬੀ ਦੇ ਇਟਰੇਸ਼ਨ ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਸ਼ਾਨਦਾਰ ਪੈਟਰਨਸ ਦੇ ਪਿੱਛੇ ਦਾ ਮੈਕਾਨਿਜ਼ਮ ਹੈ।

## ਬੇਸਿਕ 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!
```

ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਰੂਬੀ ਦੀਆਂ ਇਟਰੇਸ਼ਨ ਮੈਥਡਸ (`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` ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਰੂਬੀ ਗਿਆਨ ਹੈ — ਇਹ ਉਹ ਮੈਕਾਨਿਜ਼ਮ ਹੈ ਜਿਸ ਤਰ੍ਹਾਂ ਮੈਥਡ ਬਲਾਕਾਂ ਨੂੰ ਇਨਵੋਕ ਕਰਦੇ ਹਨ, ਜੋ ਰੂਬੀ ਦੇ ਦਸਤਖਤ ਇਟਰੇਸ਼ਨ ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਸ਼ਾਨਦਾਰ ਪੈਟਰਨਸ ਨੂੰ ਸਮਝਣ ਲਈ ਇਸ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਬਣਾਉਂਦਾ ਹੈ। `yield` ਇੱਕ ਮੈਥਡ ਨੂੰ ਪਾਸ ਕੀਤੇ ਗਏ ਬਲਾਕ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ (ਇਸ ਨੂੰ ਕੰਟਰੋਲ ਟ੍ਰਾਂਸਫਰ ਕਰਦੇ ਹੋਏ, ਇੱਛਕ ਤੌਰ ਤੇ ਮੁੱਲ ਪਾਸ ਕਰਦੇ ਹੋਏ), ਜੋ ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਹੈ ਜਿਸ ਤਰ੍ਹਾਂ ਰੂਬੀ ਦੀਆਂ ਇਟਰੇਸ਼ਨ ਮੈਥਡਸ (`each`, `map`, `select`) ਅੰਦਰੂਨੀ ਤੌਰ ਤੇ ਕਾਮ ਕਰਦੀਆਂ ਹਨ — ਉਹ ਹਰੇਕ ਐਲੀਮੈਂਟ ਨੂੰ ਬਲਾਕ ਤੱਕ `yield` ਕਰਦੇ ਹਨ।

ਇਸ ਨੂੰ ਸਮਝਣਾ ਰੂਬੀ ਦੀ ਬਲਾਕ-ਆਧਾਰਿਤ ਇਟਰੇਸ਼ਨ ਨੂੰ ਸਪਸ਼ਟ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ **ਆਪਣੀਆਂ ਮੈਥਡਸ ਲਿਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਜੋ ਬਲਾਕਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੀਆਂ ਹਨ** — ਸ਼ਾਨਦਾਰ APIs, ਕਸਟਮ ਇਟਰੇਟਰਸ, ਸਰੋਤ-ਪ੍ਰਬੰਧਨ ਮੈਥਡਸ (ਬਲਾਕ ਦੇ ਦੁਆਲੇ ਸੈਟਅਪ/ਟੀਅਰਡਾਊਨ), ਅਤੇ DSLs ਬਣਾਉਣ ਲਈ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਯੋਗਤਾ।

`yield` (ਬਲਾਕ ਨੂੰ ਕਾਲ ਕਰਨਾ, ਇਸ ਨੂੰ ਆਰਗੁਮੈਂਟਸ ਪਾਸ ਕਰਨਾ), `block_given?` (ਸੁਰੱਖਿਤ ਤੌਰ ਤੇ ਚੈਕ ਕਰਨਾ ਕਿ ਕੀ ਇੱਕ ਬਲਾਕ ਪਾਸ ਕੀਤਾ ਗਿਆ ਸੀ, ਤ੍ਰੁਟੀਆਂ ਤੋਂ ਬਚਦੇ ਹੋਏ), ਅਤੇ `&block` (ਸਪੱਸ਼ਟ ਤੌਰ ਤੇ ਬਲਾਕ ਨੂੰ Proc ਦੇ ਤੌਰ ਤੇ ਕੈਪਚਰ ਕਰਨਾ) ਨੂੰ ਜਾਣਨਾ ਦੋਵੇਂ ਰੂਬੀ ਦੀ ਇਟਰੇਸ਼ਨ ਅਤੇ ਬਲਾਕ-ਸਵੀਕਾਰ ਕਰਨ ਵਾਲੀਆਂ ਮੈਥਡਸ ਦੀ ਕਾਰਜ ਨੂੰ ਸਮਝਣ ਅਤੇ ਆਪਣੀਆਂ ਬਲਾਕ-ਆਧਾਰਿਤ ਮੈਥਡਸ ਲਿਖਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਕਿਉਂਕਿ ਬਲਾਕ ਰੂਬੀ ਲਈ ਕੇਂਦਰੀ ਹਨ ਅਤੇ `yield` ਉਹ ਤਰੀਕਾ ਹੈ ਜਿਸ ਨਾਲ ਮੈਥਡ ਉਨ੍ਹਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ, `yield` ਨੂੰ ਸਮਝਣਾ ਰੂਬੀ ਦੀ ਸਭ ਤੋਂ ਵਿਲੱਖਣ ਵਿਸ਼ੇਸ਼ਤਾ (ਬਲਾਕਸ) ਦੀ ਤੁਹਾਡੀ ਸਮਝ ਨੂੰ ਗਹਿਰਾ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਉਸ ਕਿਸਮ ਦੀਆਂ ਸ਼ਾਨਦਾਰ, ਬਲਾਕ-ਸਵੀਕਾਰ ਕਰਨ ਵਾਲੀਆਂ ਮੈਥਡਸ ਲਿਖਣ ਦੀ ਸਮਰੱਥਾ ਦਿੰਦਾ ਹੈ ਜੋ ਰੂਬੀ ਨੂੰ ਸ਼ਾਨਦਾਰ ਬਣਾਉਂਦੀਆਂ ਹਨ — ਸਾਫ APIs ਬਣਾਉਣ ਲਈ ਇੱਕ ਮੁੱਲਵਾਨ ਕੌਸ਼ਲ ਅਤੇ ਇੱਕ ਆਮ ਇੰਟਰਵਿਊ ਵਿਸ਼ਾ ਜੋ ਇਸ ਗੱਲ ਦੀ ਸਮਝ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਰੂਬੀ ਦਾ ਬਲਾਕ ਮੈਕਾਨਿਜ਼ਮ ਅਸਲ ਵਿੱਚ ਕਿਸ ਤਰ੍ਹਾਂ ਕਾਮ ਕਰਦਾ ਹੈ।