Hvad er duck typing i Ruby?

Question

Accepted Answer

**Duck typing** er et princip, hvor et objekts egnethed bestemmes af **hvilke metoder det reagerer på**, ikke dets klasse eller type — "hvis det går som en and og kværkler som en and, så er det en and." I Ruby betyder det, at du er interesseret i, hvad et objekt *kan gøre* (har metoden), ikke hvilken type det er. Dette muliggør fleksibel, polymorfe kode uden arv eller interfaces.

## Princippet: adfærd frem for 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, der har en `quack`-metode — en `Duck`, en `Person`, hvad som helst. Den tjekker ikke typen; den kalder bare metoden. Dette er polymorfisme uden delt arv eller eksplicitte interfaces.

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

## Tjek for adfærd (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
```

Idiomalsk Ruby bruger `respond_to?` (har det denne metode?) i stedet for `is_a?` (er det denne type?), når fleksibilitet betyder noget — fokus på **evne, ikke klasse**.

## Hvorfor det betyder noget

Duck typing er et grundlæggende Ruby-princip og en definerende karakteristik for, hvordan Ruby opnår fleksibilitet og polymorfisme, så forståelse af det er vigtig for at skrive idiomatisk Ruby.

Kerneidéen — at et objekts egnethed bestemmes af **hvad det kan gøre (dets metoder), ikke dets klasse/type** — muliggør fleksibel, polymorfe kode *uden* at kræve delt arv eller eksplicitte interfaces (modsat statisk typede sprog, hvor polymorfisme kræver fælles basisklasser eller interfaces).

Dette er befriende og kraftfuldt: en metode fungerer med ethvert objekt, der reagerer på de nødvendige metoder, så du kan transmitte hvad som helst, der "kværkler" — forskellige klasser, brugerdefinerede objekter — og det virker bare, hvilket gør koden genanvendelig og tilpasningsdygtig.

Forståelse af duck typing forklarer Rubys fleksible, adfærdsfokuserede stil og hvorfor Ruby-kode typisk er afhængig af **metodetilstedeværelse** (`respond_to?`) snarere end **type-checks** (`is_a?`) — fokus på evne frem for klasse er den idiomatiske Ruby-tilgang.

Dette princip ligger til grund for meget af Rubys elegance og fleksibiliteten i dens biblioteker og frameworks (som fungerer med hvad som helst, der leverer de rigtige metoder, som alt med `each` eller `<<`).

At forstå duck typing — at Ruby er interesseret i adfærd, ikke type, muliggør interface-fri polymorfisme, og at idiomatisk Ruby tjekker evne snarere end klasse — er vigtigt for at skrive fleksibel, idiomatisk Ruby og for at forstå den dynamiske, adfærdsorienterede filosofi, der adskiller Ruby fra statisk typede sprog.

Det er et kernekoncept, der fanger Rubys fleksible design og et hyppigt interviewemne, der afspejler forståelse af dynamisk, duck-typet programmering.