Hva er duck typing i Ruby?

Question

Accepted Answer

**Duck typing** er et prinsipp der et objekts egnethet bestemmes av **hvilke metoder det responderer på**, ikke klassen eller typen — "hvis det går som en and og kvekker som en and, er det en and." I Ruby bryr du deg om at et objekt *kan gjøre* noe (har metoden), ikke hva type det er. Dette gjør det mulig med fleksibel, polymorfi kode uten arv eller grensesnitt.

## Prinsippet: oppførsel fremfor type

```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` fungerer med **ethvert** objekt som har en `quack`-metode — en `Duck`, en `Person`, hva som helst. Den sjekker ikke typen; den bare kaller metoden. Dette er polymorfisme uten delt arv eller eksplisitte grensesnitt.

## Duck typing i praksis

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

## Sjekke for oppførsel (ikke type)

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

Idiomasantisk Ruby bruker `respond_to?` (har den denne metoden?) fremfor `is_a?` (er den denne typen?) når fleksibilitet er viktig — fokus på **evne, ikke klasse**.

## Hvorfor det er viktig

Duck typing er et grunnleggende Ruby-prinsipp og en definierende karakteristikk av hvordan Ruby oppnår fleksibilitet og polymorfisme, så å forstå det er viktig for å skrive idiomatisk Ruby.

Kjerneideen — at et objekts egnethet bestemmes av **hva det kan gjøre (dets metoder), ikke klassen/typen** — muliggjør fleksibel, polymorfi kode *uten* å kreve delt arv eller eksplisitte grensesnitt (i motsetning til statisk typede språk der polymorfisme trenger felles basisklasser eller grensesnitt).

Dette er frigjørende og kraftfullt: en metode fungerer med ethvert objekt som responderer på de nødvendige metodene, så du kan sende inn hva som helst som "kvekker" — ulike klasser, egendefinerte objekter — og det fungerer bare, noe som gjør koden gjenbrukbar og tilpasningsdyktig.

Å forstå duck typing forklarer Rubys fleksible, oppførsels-fokuserte stil og hvorfor Ruby-kode typisk er avhengig av **metodetilstedeværelse** (`respond_to?`) fremfor **typekontroller** (`is_a?`) — fokus på evne fremfor klasse er den idiomatiske Ruby-tilnærmingen.

Dette prinsippet ligger til grunn for mye av Rubys eleganse og fleksibiliteten i bibliotekene og rammeverket (som fungerer med hva som helst som gir de riktige metodene, som hva som helst med `each` eller `<<`).

Å forstå duck typing — at Ruby bryr seg om oppførsel ikke type, muliggjør grensesnittfri polymorfisme, og at idiomatisk Ruby sjekker evne fremfor klasse — er viktig for å skrive fleksibel, idiomatisk Ruby og for å forstå den dynamiske, oppførsels-orienterte filosofien som skiller Ruby fra statisk typede språk.

Det er et grunnleggende konseptuelt emne som fanger Rubys fleksible design og et hyppig intervjuspørsmål som gjenspeiler forståelse av dynamisk, duck-typet programmering.