Duck typing trong Ruby là gì?

Question

Accepted Answer

**Duck typing** là một nguyên tắc trong đó sự phù hợp của một object được xác định bởi **những method mà nó phản hồi (respond to)**, không phải class hay kiểu của nó — "nếu nó đi như vịt và kêu quạc quạc như vịt, thì nó là vịt." Trong Ruby, bạn quan tâm rằng một object *có thể làm* điều gì đó (có method đó), không phải nó thuộc kiểu gì. Điều này cho phép code linh hoạt, đa hình mà không cần kế thừa hay interface.

## Nguyên tắc: hành vi hơn kiểu

```ruby
# method này hoạt động với BẤT KỲ object nào có method `quack` —
# bất kể class của nó. Không cần interface hay kế thừa.
def make_it_quack(duck)
  duck.quack            # chỉ quan tâm rằng `duck` phản hồi `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!" — hoạt động! (nó có quack)
```

`make_it_quack` hoạt động với **bất kỳ** object nào có method `quack` — một `Duck`, một `Person`, bất cứ thứ gì. Nó không kiểm tra kiểu; nó chỉ gọi method. Đây là đa hình mà không có kế thừa chung hay interface tường minh.

## Duck typing thực tế

```ruby
# code Ruby thường dựa vào sự hiện diện của method, không phải kiểm tra kiểu
def process(items)
  items.each { |i| puts i }   # hoạt động với BẤT KỲ object nào có `each`
  # → một Array, một Set, một Range, một Enumerable tùy chỉnh... tất cả "kêu quạc" với each
end

# toán tử <<: hoạt động trên bất cứ thứ gì định nghĩa nó
def append_to(collection, item)
  collection << item          # hoạt động trên Array, String, IO, Logger... tất cả đều có <<
end
```

## Kiểm tra hành vi (không phải kiểu)

```ruby
# ✅ duck-typed — kiểm tra xem nó có phản hồi một method không (hành vi)
if obj.respond_to?(:each)
  obj.each { ... }
end

# ❌ ít đậm chất Ruby hơn — kiểm tra class/kiểu
if obj.is_a?(Array)   # cứng nhắc; duck typing thích kiểm tra năng lực hơn
end
```

Ruby idiomatic dùng `respond_to?` (nó có method này không?) thay vì `is_a?` (nó có phải kiểu này không?) khi sự linh hoạt quan trọng — tập trung vào **năng lực, không phải class**.

## Tại sao điều này quan trọng

Duck typing là một nguyên tắc nền tảng của Ruby và là đặc điểm định danh cho cách Ruby đạt được sự linh hoạt và đa hình, nên hiểu nó là quan trọng để viết Ruby idiomatic.

Ý tưởng cốt lõi — rằng sự phù hợp của một object được xác định bởi **những gì nó có thể làm (method của nó), không phải class/kiểu** — cho phép code linh hoạt, đa hình *mà không* yêu cầu kế thừa chung hay interface tường minh (khác với các ngôn ngữ định kiểu tĩnh nơi đa hình cần base class chung hoặc interface).

Điều này giải phóng và mạnh mẽ: một method hoạt động với bất kỳ object nào phản hồi các method cần thiết, nên bạn có thể truyền vào bất cứ thứ gì "kêu quạc" — các class khác nhau, object tùy chỉnh — và nó cứ thế hoạt động, làm cho code tái sử dụng được và thích nghi được.

Hiểu duck typing giải thích phong cách linh hoạt, tập trung vào hành vi của Ruby và vì sao code Ruby thường dựa vào **sự hiện diện của method** (`respond_to?`) thay vì **kiểm tra kiểu** (`is_a?`) — tập trung vào năng lực hơn class là cách tiếp cận idiomatic của Ruby.

Nguyên tắc này nền tảng cho phần lớn sự thanh lịch của Ruby và sự linh hoạt của các thư viện và framework của nó (vốn hoạt động với bất cứ thứ gì cung cấp các method đúng, như bất cứ thứ gì có `each` hoặc `<<`).

Nắm bắt duck typing — rằng Ruby quan tâm về hành vi không phải kiểu, cho phép đa hình không cần interface, và rằng Ruby idiomatic kiểm tra năng lực thay vì class — là quan trọng để viết Ruby linh hoạt, idiomatic và để hiểu triết lý động, hướng-hành-vi phân biệt Ruby với các ngôn ngữ định kiểu tĩnh.

Đó là một chủ đề khái niệm cốt lõi nắm bắt thiết kế linh hoạt của Ruby và là điểm phỏng vấn thường gặp phản ánh sự hiểu biết về lập trình động, duck-typed.