Apakah duck typing dalam Ruby?

Question

Accepted Answer

**Duck typing** ialah prinsip di mana kesesuaian sesuatu objek ditentukan oleh **method apa yang ia respons**, bukan class atau jenisnya — "jika ia berjalan seperti itik dan berbunyi seperti itik, maka ia ialah itik." Dalam Ruby, anda mengambil berat bahawa sesuatu objek *boleh melakukan* sesuatu (mempunyai method tersebut), bukan jenis apa ia. Ini membolehkan kod yang fleksibel dan polimorfik tanpa pewarisan atau interface.

## Prinsipnya: tingkah laku mengatasi jenis

```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` berfungsi dengan **mana-mana** objek yang mempunyai method `quack` — sama ada `Duck`, `Person`, apa sahaja. Ia tidak memeriksa jenisnya; ia hanya memanggil method tersebut. Ini ialah polimorfisme tanpa pewarisan dikongsi atau interface eksplisit.

## Duck typing dalam dunia sebenar

```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 tingkah laku (bukan jenis)

```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?` (adakah ia mempunyai method ini?) berbanding `is_a?` (adakah ia jenis ini?) apabila fleksibiliti penting — memfokuskan pada **keupayaan, bukan class**.

## Mengapa ia penting

Duck typing ialah prinsip asas Ruby dan ciri penentu bagaimana Ruby mencapai fleksibiliti dan polimorfisme, jadi memahaminya adalah penting untuk menulis Ruby yang idiomatik.

Idea teras — bahawa kesesuaian sesuatu objek ditentukan oleh **apa yang ia boleh lakukan (method-methodnya), bukan class/jenisnya** — membolehkan kod yang fleksibel dan polimorfik *tanpa* memerlukan pewarisan dikongsi atau interface eksplisit (tidak seperti bahasa yang ditaip secara statik di mana polimorfisme memerlukan base class atau interface bersama).

Ini membebaskan dan berkuasa: sesuatu method berfungsi dengan mana-mana objek yang merespons method yang diperlukan, jadi anda boleh menghantar apa sahaja yang "quack" — class berbeza, objek tersuai — dan ia berfungsi begitu sahaja, menjadikan kod boleh guna semula dan boleh disesuaikan.

Memahami duck typing menjelaskan gaya Ruby yang fleksibel dan berfokus pada tingkah laku serta mengapa kod Ruby lazimnya bergantung pada **kehadiran method** (`respond_to?`) berbanding **pemeriksaan jenis** (`is_a?`) — memfokuskan pada keupayaan mengatasi class ialah pendekatan Ruby yang idiomatik.

Prinsip ini mendasari sebahagian besar keanggunan Ruby serta fleksibiliti pustaka dan rangka kerjanya (yang berfungsi dengan apa sahaja yang menyediakan method yang betul, seperti apa sahaja yang mempunyai `each` atau `<<`).

Menguasai duck typing — bahawa Ruby mengambil berat tentang tingkah laku bukan jenis, membolehkan polimorfisme tanpa interface, dan bahawa Ruby idiomatik memeriksa keupayaan berbanding class — adalah penting untuk menulis Ruby yang fleksibel dan idiomatik serta untuk memahami falsafah dinamik dan berorientasikan tingkah laku yang membezakan Ruby daripada bahasa yang ditaip secara statik.

Ia merupakan topik konseptual teras yang menangkap reka bentuk fleksibel Ruby dan satu poin temu duga yang kerap mencerminkan pemahaman tentang pengaturcaraan dinamik bergaya duck-typed.