Apa iku duck typing ing Ruby?

Question

Accepted Answer

**Duck typing** minangka prinsip ing ngendi kesesuaian obyek ditetepake dening **metode apa sing bisa ditanggapi**, dudu kelas utawa tipe — "yen mlaku kaya bebek lan kebo kaya bebek, banjur iku bebek." Ing Ruby, kowe peduli yen obyek bisa nglakokne apa (duwe metode), dudu tipe apa. Iki ngakibatake kode sing luwes lan polimorfik tanpa warisan utawa antarmuka.

## Prinsip: perilaku tinimbang tipe

```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` bisa dipaké karo **obyek apa wae** sing duwe metode `quack` — `Duck`, `Person`, apa wae. Iku ora nyambut tipe; mung ngadani metode. Iki minangka polimorfisme tanpa warisan bareng-bareng utawa antarmuka eksplisit.

## Duck typing ing donya nyata

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

## Mriksa perilaku (dudu tipe)

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

Ruby idiomatik nggunakne `respond_to?` (apa duwe metode iki?) tinimbang `is_a?` (apa iki tipe iki?) nalika fleksibilitas penting — fokus ing **kemampuan, dudu kelas**.

## Dene penting

Duck typing minangka prinsip fundamental Ruby lan ciri khas carane Ruby nggayuh fleksibilitas lan polimorfisme, dadi ngerti-ne penting kanggo nulis Ruby idiomatik.

Gagasan dhadine — yen kesesuaian obyek ditetepake dening **apa bisa ditindakne (metode-ne), dudu kelas/tipe-ne** — ngakibatake kode polimorfik lan luwes *tanpa* kudu warisan bareng utawa antarmuka eksplisit (ora kaya basa sing estatik tipene ing ngendi polimorfisme kudu kelas basis utawa antarmuka bareng).

Iki murah lan kuwat: metode bisa dipaké karo obyek apa wae sing nanggepi metode sing dibutuhne, dadi bisa isine apa wae sing "kebo" — kelas beda, obyek khusus — lan mung bisa, nggawene kode bisa dipaké maneh lan bisa disesuo.

Ngerti duck typing nerangne gaya Ruby sing luwes lan focus-ne ing perilaku, lan dene kode Ruby biasane gumantung ing **kehadiran metode** (`respond_to?`) tinimbang **cek tipe** (`is_a?`) — focus ing kemampuan tinimbang kelas minangka cara idiomatik Ruby.

Prinsip iki minangka dhasar akeh keluwesan Ruby lan fleksibilitas pustaka lan framework-ne (sing bisa dipaké karo apa wae sing nyedhiyakne metode sing luwes, kaya apa wae sing duwe `each` utawa `<<`).

Ngerti duck typing — yen Ruby peduli ing perilaku dudu tipe, ngakibatake polimorfisme tanpa antarmuka, lan yen Ruby idiomatik cek kemampuan tinimbang kelas — penting kanggo nulis Ruby luwes lan idiomatik lan kanggo ngerti filosofi dinamis lan perilaku-oriented sing mbedakne Ruby saka basa sing estatik tipene.

Iki topik konseptual dhasar sing nyedhiyakne desain Ruby luwes lan titik wawancara sing asring ditakokne sing nerangne pemahaman program dinamis lan duck-typed.