Ruby में duck typing क्या है?

Question

Accepted Answer

**Duck typing** एक सिद्धांत है जहाँ किसी object की उपयुक्तता इस बात से निर्धारित होती है कि वह **किन methods का जवाब देता है**, न कि इसके class या type से — "यदि यह एक बत्तख की तरह चलता है और एक बत्तख की तरह quack करता है, तो यह एक बत्तख है।" Ruby में, आप इस बात की परवाह करते हैं कि एक object कुछ *कर सकता है* (method है), न कि यह किस type का है। यह inheritance या interfaces के बिना लचीला, polymorphic code सक्षम बनाता है।

## The principle: behavior over 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` **किसी भी** object के साथ काम करता है जिसमें एक `quack` method है — एक `Duck`, एक `Person`, कुछ भी। यह type की जाँच नहीं करता; यह बस method call करता है। यह साझा inheritance या explicit interfaces के बिना polymorphism है।

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

## Checking for behavior (not 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
```

idiomatic Ruby जब लचीलापन मायने रखता है तो `is_a?` (क्या यह यह type है?) के बजाय `respond_to?` (क्या इसमें यह method है?) का उपयोग करता है — **capability पर ध्यान केंद्रित करते हुए, class पर नहीं**।

## यह क्यों महत्वपूर्ण है

Duck typing एक मूलभूत Ruby सिद्धांत है और इस बात की एक परिभाषित विशेषता है कि Ruby लचीलापन और polymorphism कैसे प्राप्त करता है, इसलिए इसे समझना idiomatic Ruby लिखने के लिए महत्वपूर्ण है।

मूल विचार — कि किसी object की उपयुक्तता इस बात से निर्धारित होती है कि **यह क्या कर सकता है (इसके methods), न कि इसके class/type से** — लचीला, polymorphic code सक्षम बनाता है *बिना* साझा inheritance या explicit interfaces की आवश्यकता के (statically-typed languages के विपरीत जहाँ polymorphism को common base classes या interfaces की आवश्यकता होती है)।

यह मुक्तिदायक और शक्तिशाली है: एक method किसी भी object के साथ काम करता है जो आवश्यक methods का जवाब देता है, इसलिए आप कुछ भी पास कर सकते हैं जो "quacks" करता है — विभिन्न classes, custom objects — और यह बस काम करता है, code को पुन: प्रयोज्य और अनुकूलनीय बनाते हुए।

duck typing को समझना Ruby की लचीली, behavior-केंद्रित शैली को स्पष्ट करता है और यह कि Ruby code आमतौर पर **type checks** (`is_a?`) के बजाय **method presence** (`respond_to?`) पर क्यों निर्भर करता है — class पर capability को प्राथमिकता देना idiomatic Ruby दृष्टिकोण है।

यह सिद्धांत Ruby की elegance और इसकी libraries और frameworks के लचीलेपन के अधिकांश का आधार है (जो सही methods प्रदान करने वाली किसी भी चीज़ के साथ काम करते हैं, जैसे `each` या `<<` वाली कोई भी चीज़)।

duck typing को समझना — कि Ruby type नहीं बल्कि behavior की परवाह करता है, interface-free polymorphism सक्षम करते हुए, और यह कि idiomatic Ruby class के बजाय capability की जाँच करता है — लचीला, idiomatic Ruby लिखने और उस dynamic, behavior-oriented दर्शन को समझने के लिए महत्वपूर्ण है जो Ruby को statically-typed languages से अलग करता है।

यह एक मूल वैचारिक विषय है जो Ruby के लचीले design को पकड़ता है और एक बार-बार आने वाला interview बिंदु है जो dynamic, duck-typed programming की समझ को दर्शाता है।