Kas yra duck typing Ruby?

Question

Accepted Answer

**Duck typing** yra principas, kuriame objekto tinkamumas nustatomas pagal **kokius metodus jis atsakinėja**, o ne jo klasę ar tipą — "jei jis vaikštai kaip antis ir kvakinėja kaip antis, tai jis antis". Ruby kalba tu rūpiesi, kad objektas *gali padaryti* ką nors (turi metodą), o ne kokio tipo jis yra. Tai leidžia kurti lankstų, polimorfų kodą be paveldėjimo ar sąsajų.

## Principas: elgesys virš tipo

```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` veikia su **bet kuriuo** objektu, kuris turi `quack` metodą — `Duck`, `Person`, bet kuo. Jis nepatikrina tipo; jis tiesiog iškviečia metodą. Tai yra polimorfizmas be bendro paveldėjimo ar aiškių sąsajų.

## Realaus pasaulio duck typing

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

## Elgesio tikrinimas (ne tipo)

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

Idiomatinė Ruby naudoja `respond_to?` (ar jis turi šį metodą?) vietoj `is_a?` (ar jis yra šio tipo?) kai svarbiausia lankstumas — sutelkdamasi į **galimybę, o ne klasę**.

## Kodėl tai svarbu

Duck typing yra fundamentinis Ruby principas ir apibrėžiantis Ruby lankstumo ir polimorfizmo pasiekimo būdą, todėl jo supratimas yra svarbus idomatinio Ruby kodo rašymui.

Pagrindinė idėja — kad objekto tinkamumas nustatomas pagal **ką jis gali padaryti (jo metodus), o ne jo klasę/tipą** — leidžia kurti lankstų, polimorfų kodą *be* bendro paveldėjimo ar aiškių sąsajų reikalavimo (priešingai nei statiškai tipizuotose kalbose, kur polimorfizmas reikalauja bendrų baziniu klasių ar sąsajų).

Tai yra liberališka ir galinga: metodas veikia su bet kuriuo objektu, kuris atsakinėja reikalingus metodus, todėl tu gali perduoti ką nors, kas "kvakinėja" — skirtingas klases, pasirinktinius objektus — ir tai tiesiog veikia, padarytas kodą pakartojimui tinkamą ir pritaikymui lengvą.

Duck typing supratimas paaiškina Ruby lanksčią, elgesiu orientuotą stilių ir kodėl Ruby kodas paprastai pasitikima **metodo buvimu** (`respond_to?`) o ne **tipo patikromis** (`is_a?`) — lankstumo pagal galimybę virš klasės yra idiomatinis Ruby metodas.

Šis principas yra Ruby eleganciškumo esmoje ir jo bibliotekų bei sistemų lankstumo pagrindas (kurie veikia su bet kuo, tiekiančiu reikalingus metodus, kaip bet kas su `each` ar `<<`).

Suvokus duck typing — kad Ruby rūpinasiis elgesiu, o ne tipu, leidžiantis beinterfeiso polimorfizmą, ir kad idiomatinė Ruby tikrina galimybę o ne klasę — yra svarbu rašant lankstų, idomatinį Ruby kodą ir suprantant dinaminę, elgesiu orientuotą filosofiją, kuri atskiria Ruby nuo statiškai tipizuotų kalbų.

Tai yra pagrindinė konceptualinė tema, kuri atspindi Ruby lankstų dizainą ir dažnas pokalbio metu iškylanti tema, rodanti supratimą apie dinaminį, duck-typed programavimą.