Vad är duck typing i Ruby?

Question

Accepted Answer

**Duck typing** är en princip där ett objekts lämplighet bestäms av **vilka metoder det svarar på**, inte dess klass eller typ — "om det går som en anka och kväcker som en anka, då är det en anka." I Ruby bryr du dig om att ett objekt *kan göra* något (har metoden), inte vilken typ det är. Detta möjliggör flexibel, polymorf kod utan arv eller gränssnitt.

## Principen: beteende över typ

```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` fungerar med **vilket som helst** objekt som har en `quack`-metod — en `Duck`, en `Person`, vad som helst. Den kontrollerar inte typen; den anropar bara metoden. Detta är polymorfism utan gemensamt arv eller explicita gränssnitt.

## Duck typing i verkligheten

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

## Kontrollera beteende (inte typ)

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

Idiomatisk Ruby använder `respond_to?` (har det denna metod?) över `is_a?` (är det denna typ?) när flexibilitet är viktig — fokusering på **kapacitet, inte klass**.

## Varför det är viktigt

Duck typing är en fundamental Ruby-princip och en karakteristisk egenskap för hur Ruby uppnår flexibilitet och polymorfism, så att förstå det är viktigt för att skriva idiomatisk Ruby.

Kärnidén — att ett objekts lämplighet bestäms av **vad det kan göra (dess metoder), inte dess klass/typ** — möjliggör flexibel, polymorf kod *utan* att kräva gemensamt arv eller explicita gränssnitt (till skillnad från statiskt typade språk där polymorfism kräver gemensamma basklasser eller gränssnitt).

Detta är befriande och kraftfullt: en metod fungerar med vilket objekt som helst som svarar på de nödvändiga metoderna, så du kan skicka in vad som helst som "kväcker" — olika klasser, anpassade objekt — och det fungerar bara, vilket gör koden återanvändbar och anpassningsbar.

Att förstå duck typing förklarar Rubys flexibla, beteendefokuserad stil och varför Ruby-kod vanligtvis förlitar sig på **metodtillgänglighet** (`respond_to?`) snarare än **typkontroller** (`is_a?`) — att fokusera på kapacitet över klass är den idiomatiska Ruby-metoden.

Denna princip ligger till grund för mycket av Rubys elegans och flexibiliteten hos dess bibliotek och ramverk (som fungerar med vad som helst som tillhandahåller de rätta metoderna, som vad som helst med `each` eller `<<`).

Att förstå duck typing — att Ruby bryr sig om beteende inte typ, vilket möjliggör polymorfism utan gränssnitt, och att idiomatisk Ruby kontrollerar kapacitet snarare än klass — är viktigt för att skriva flexibel, idiomatisk Ruby och för att förstå den dynamiska, beteendeorienterade filosofin som skiljer Ruby från statiskt typade språk.

Det är ett koncepuellt kärnämne som fångar Rubys flexibla design och en vanlig intervjufråga som återspeglar förståelsen för dynamisk, duck-typifierad programmering.