`yield` inafanyaje kazi ndani ya methods?

Question

Accepted Answer

**`yield`** huita **block** iliyopitishwa kwa method — huhamisha udhibiti kwenda kwa block, kwa hiari ikipitisha thamani kwake, kisha huendelea na method. Ndivyo methods zinavyoita block zilizopewa, na ni utaratibu ulio nyuma ya iteration ya Ruby na patterns nyingi za kifahari.

## Yield ya msingi — kuita block iliyopewa

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

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

Method inapoita `yield`, huendesha block iliyopitishwa kwake (ndani ya `{ }` au `do...end`). Method hudhibiti *lini* (na mara ngapi) block inaendeshwa.

## Yield yenye arguments — kupitisha thamani kwa 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)` hupitisha thamani kwa parameters za block (`|key, value|`) — hivi ndivyo methods za iteration zinavyompa kila element block.

## Kutekeleza iteration kwa 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!
```

Hii inaonyesha jinsi methods za iteration za Ruby (`each`, `map`, n.k.) zinavyofanya kazi ndani — zinampa (`yield`) block kila element.

## block_given? na kunasa 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?` hukagua kama block ilipitishwa (kuepuka `LocalJumpError`), na `&block` hunasa block kama Proc object unayoweza kuhifadhi au kupitisha mbele.

## Kwa nini ni muhimu

Kuelewa `yield` ni maarifa muhimu ya Ruby — ni utaratibu ulio nyuma ya jinsi methods zinavyoita block, ambao unaunda msingi wa iteration maalum ya Ruby na patterns nyingi za kifahari, hivyo kuielewa kunaangaza jinsi sehemu kubwa ya Ruby inavyofanya kazi. `yield` huita block iliyopitishwa kwa method (ikihamisha udhibiti kwake, kwa hiari ikipitisha thamani), ambayo ndiyo hasa jinsi methods za iteration za Ruby (`each`, `map`, `select`) zinavyofanya kazi ndani — zinampa (`yield`) block kila element.

Kuelewa hili kunaondoa fumbo la iteration inayotegemea block ya Ruby na kukuwezesha **kuandika methods zako mwenyewe zinazokubali block** — uwezo wenye nguvu wa kuunda APIs za kueleza, iterators maalum, methods za usimamizi wa rasilimali (setup/teardown kuzunguka block), na DSLs.

Kujua `yield` (kuita block, kupitisha arguments kwake), `block_given?` (kukagua kwa usalama kama block ilipitishwa, kuepuka makosa), na `&block` (kunasa block kama Proc kwa uwazi) ni muhimu kwa kuelewa jinsi methods za iteration na za kukubali block za Ruby zinavyofanya kazi na kwa kuandika methods zako mwenyewe zinazotegemea block.

Kwa kuwa block ni kiini cha Ruby na `yield` ndiyo jinsi methods zinavyozitumia, kuelewa `yield` kunaimarisha ufahamu wako wa kipengele bainifu zaidi cha Ruby (block) na kukuwezesha kuandika aina ile ya methods za kifahari zinazokubali block zinazofanya Ruby kuwa ya kueleza — ujuzi wenye thamani wa kujenga APIs safi na mada ya mahojiano inayojirudia ambayo inaonyesha uelewa wa jinsi utaratibu wa block wa Ruby unavyofanya kazi kihalisia chini ya pazia.