Apa itu duck typing dalam Ruby?

Question

Accepted Answer

**Duck typing** adalah prinsip di mana kesesuaian suatu objek ditentukan oleh **metode apa yang dapat direspons**, bukan kelasnya atau tipenya — "jika berjalan seperti bebek dan bersuara seperti bebek, itu adalah bebek." Dalam Ruby, Anda peduli bahwa objek *dapat melakukan* sesuatu (memiliki metode), bukan tipe objeknya. Ini memungkinkan kode yang fleksibel dan polimorfik tanpa warisan atau antarmuka.

## Prinsipnya: perilaku daripada 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` bekerja dengan **objek apa pun** yang memiliki metode `quack` — sebuah `Duck`, `Person`, apa saja. Ini tidak memeriksa tipenya; ini hanya memanggil metodenya. Ini adalah polimorfisme tanpa warisan bersama atau antarmuka eksplisit.

## Duck typing di dunia 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
```

## Memeriksa perilaku (bukan 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 menggunakan `respond_to?` (apakah memiliki metode ini?) daripada `is_a?` (apakah ini tipe ini?) ketika fleksibilitas penting — fokus pada **kemampuan, bukan kelas**.

## Mengapa ini penting

Duck typing adalah prinsip fundamental Ruby dan karakteristik yang menentukan bagaimana Ruby mencapai fleksibilitas dan polimorfisme, jadi memahaminya penting untuk menulis Ruby yang idiomatik.

Ide inti — bahwa kesesuaian objek ditentukan oleh **apa yang dapat dilakukannya (metodenya), bukan kelasnya/tipenya** — memungkinkan kode yang fleksibel dan polimorfik *tanpa* memerlukan warisan bersama atau antarmuka eksplisit (tidak seperti bahasa yang diketik secara statis di mana polimorfisme membutuhkan kelas dasar bersama atau antarmuka).

Ini membebaskan dan kuat: suatu metode bekerja dengan objek apa pun yang merespons metode yang diperlukan, jadi Anda dapat meneruskan apa pun yang "bersuara" — kelas berbeda, objek khusus — dan itu hanya bekerja, membuat kode dapat digunakan kembali dan dapat beradaptasi.

Memahami duck typing menjelaskan gaya Ruby yang fleksibel dan berorientasi pada perilaku, dan mengapa kode Ruby biasanya bergantung pada **kehadiran metode** (`respond_to?`) daripada **pemeriksaan tipe** (`is_a?`) — fokus pada kemampuan daripada kelas adalah pendekatan Ruby yang idiomatik.

Proinsip ini mendasari banyak keanggunan Ruby dan fleksibilitas perpustakaannya dan kerangka kerjanya (yang bekerja dengan apa pun yang menyediakan metode yang tepat, seperti apa pun dengan `each` atau `<<`).

Memahami duck typing — bahwa Ruby peduli dengan perilaku bukan tipe, memungkinkan polimorfisme tanpa antarmuka, dan bahwa Ruby idiomatik memeriksa kemampuan daripada kelas — penting untuk menulis Ruby yang fleksibel dan idiomatik serta untuk memahami filosofi dinamis dan berorientasi pada perilaku yang membedakan Ruby dari bahasa yang diketik secara statis.

Ini adalah topik konseptual inti yang menangkap desain fleksibel Ruby dan merupakan titik wawancara yang sering mencerminkan pemahaman tentan pemrograman dinamis dengan tipe duck.