Metotlarda yield nasıl çalışır?

Question

Accepted Answer

**`yield`** bir metoda geçilen **blok**u çağırır — kontrolü bloğa aktarır, isteğe bağlı olarak değerleri ona iletir, ardından metodu yeniden başlatır. Bu, metotların kendilerine verilen blokları nasıl çağırdığıdır ve Ruby'nin iterasyon ve birçok zarif deseninin arkasındaki mekanizmadır.

## Temel yield — verilen bloku çağır

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

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

Bir metot `yield` çağırdığında, kendisine geçilen bloku (`{ }` veya `do...end` içinde) çalıştırır. Metot *ne zaman* (ve kaç kez) bloğun çalışacağını kontrol eder.

## Argümanlarla yield — bloka değer geç

```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)` değerleri bloğun parametrelerine (`|key, value|`) iletir — bu, iterasyon metotlarının her öğeyi bloğa nasıl verdiğidir.

## yield ile iterasyon uygulama

```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!
```

Bu, Ruby'nin iterasyon metotlarının (`each`, `map`, vb.) içinde nasıl çalıştığını gösterir — her öğeyi bloğa `yield` ederler.

## block_given? ve bloku yakalama

```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?` bir bloğun geçilip geçilmediğini kontrol eder (`LocalJumpError` önleyerek) ve `&block` bloku saklayabileceğiniz veya iletebileceğiniz bir Proc nesnesi olarak yakalar.

## Neden önemli

`yield`'i anlamak önemli Ruby bilgisidir — metotların blokları nasıl çağırdığının mekanizması olup, Ruby'nin imzası iterasyon ve birçok zarif deseni destekler, bu nedenle bunu anlamak Ruby'nin nasıl çalıştığını aydınlatır. `yield` bir metoda geçilen bloku çağırır (kontrol aktararak, isteğe bağlı olarak değer ileterek), bu tamamen Ruby'nin iterasyon metotlarının (`each`, `map`, `select`) içinde nasıl çalıştığıdır — her öğeyi bloğa `yield` ederler.

Bunu anlamak Ruby'nin blok tabanlı iterasyonunu açığa çıkarır ve **bloklara kabul eden kendi metotlarınızı yazmanıza** olanak tanır — etkileyici API'ler, özel iteratörler, kaynak yönetimi metotları (bir bloğun etrafında kuruluş/yıkılış) ve DSL'ler oluşturmak için güçlü bir yetenek.

`yield`'i (bloku çağırma, ona argümanlar iletme), `block_given?`'i (güvenli şekilde bir bloğun geçilip geçilmediğini kontrol etme, hataları önleme) ve `&block`'u (bloku açıkça bir Proc olarak yakalama) bilmek, hem Ruby'nin iterasyon ve blok-kabul eden metotlarının nasıl çalıştığını anlamak hem de kendi blok tabanlı metotlarınızı yazmak için önemlidir.

Bloklar Ruby'de merkezi konumdadır ve `yield` metotların bunları nasıl kullandığıdır, `yield`'i anlamak Ruby'nin en ayırt edici özelliğine (bloklara) ilişkin anlayışınızı derinleştirir ve Ruby'yi ifadesel hale getiren zarif, blok-kabul eden metotlar yazmanıza olanak tanır — temiz API'ler oluşturmak için değerli bir beceri ve Ruby'nin blok mekanizmasının altında nasıl çalıştığı anlayışını yansıtan yaygın bir mülakat sorusudur.