Ruby'de duck typing nedir?

Question

Accepted Answer

**Duck typing**, bir nesnenin uygunluğunun **yanıt verdiği metodlar** tarafından belirlendiği bir prensiptir, sınıfı veya tipi değil — "ördek gibi yürür ve ördek gibi vak vak sesler çıkarırsa, bu bir ördektir." Ruby'de, nesnenin *ne yapabileceği* (metodun var olması) önemlidir, tipi değil. Bu, kalıtım veya arayüzler olmaksızın esnek, polimorfik kod yazmayı sağlar.

## İlke: tür yerine davranış

```ruby
# this method works with ANY object that has a `quack` method —
# regardless of its class. No interface or inheritance required.
def make_it_quack(duck)
  duck.quack            # only cares that `duck` responds to `quack`
end

class Duck
  def quack = "Quack!"
end
class Person
  def quack = "I'm imitating a duck!"
end

make_it_quack(Duck.new)     # "Quack!"
make_it_quack(Person.new)   # "I'm imitating a duck!" — works! (it has quack)
```

`make_it_quack` bir `quack` metoduna sahip **herhangi bir** nesneyle çalışır — bir `Duck`, bir `Person`, her şey olabilir. Tipi kontrol etmez; sadece metodu çağırır. Bu, paylaşılan kalıtım veya açık arayüzler olmaksızın polimorfizmdir.

## Gerçek dünya duck typing örneği

```ruby
# Ruby code typically relies on method presence, not type checks
def process(items)
  items.each { |i| puts i }   # works with ANY object that has `each`
  # → an Array, a Set, a Range, a custom Enumerable... all "quack" with each
end

# the << operator: works on anything that defines it
def append_to(collection, item)
  collection << item          # works on Array, String, IO, Logger... they all have <<
end
```

## Davranış kontrolü (tür değil)

```ruby
# ✅ duck-typed — check if it responds to a method (behavior)
if obj.respond_to?(:each)
  obj.each { ... }
end

# ❌ less Ruby-like — checking the class/type
if obj.is_a?(Array)   # rigid; duck typing prefers checking capability
end
```

Idiyomatik Ruby, esneklik önemli olduğunda `is_a?` (bu tür midir?) yerine `respond_to?` (bu metoda sahip mi?) kullanır — **sınıf değil, yetenek** üzerine odaklanır.

## Neden önemli

Duck typing, Ruby'nin temel bir prensibiyse ve Ruby'nin esnekliği ve polimorfizmi nasıl sağladığının tanımlayıcı bir özelliğidir, bu nedenle bunu anlamak idiyomatik Ruby yazması için önemlidir.

Temel fikir — bir nesnenin uygunluğunun **ne yapabileceği (metotları), sınıfı/tipi değil** tarafından belirlendiği — paylaşılan kalıtım veya açık arayüzler gerektirmeksizin esnek, polimorfik kod sağlar (statik olarak yazılan dillerin aksine, burada polimorfizm ortak temel sınıflar veya arayüzler gerektirir).

Bu özgürleştirici ve güçlüdür: bir metot, gerekli metodlara yanıt veren herhangi bir nesneyle çalışır, bu nedenle "vak vak sesler çıkaran" her şeyi — farklı sınıfları, özel nesneleri — geçebilirsiniz ve işe yarar, kodu yeniden kullanılabilir ve uyarlanabilir hale getirir.

Duck typing'i anlamak, Ruby'nin esnek, davranışa odaklı stilini ve Ruby kodunun tipik olarak neden **tür kontrolleri** (`is_a?`) yerine **metod varlığı** (`respond_to?`) ile güvendiğini açıklar — yetenek üzerinde sınıf üzerinde odaklanmak idiyomatik Ruby yaklaşımıdır.

Bu ilke, Ruby'nin zarafetinin çoğunu ve kütüphanelerinin ve çerçevelerinin esnekliğini destekler (doğru metodları sağlayan her şeyle çalışır, `each` veya `<<` gibi).

Duck typing'i kavramak — Ruby'nin davranış hakkında endişelendiğini, tür hakkında değil, arayüz gerektirmeyen polimorfizmi etkinleştirdiğini ve idiyomatik Ruby'nin sınıf yerine yetenek kontrol ettiğini — esnek, idiyomatik Ruby yazması ve dinamik, davranışa odaklı felsefesini anlaması için önemlidir, Ruby'yi statik olarak yazılan dillerden ayıran şeydir.

Bu, Ruby'nin esnek tasarımını yakalar ve Ruby'nin dinamik, duck-typed programlama anlayışını yansıtan sık sorulan bir mülakat konusudur.