Ruby मध्ये duck typing म्हणजे काय?

Question

Accepted Answer

**Duck typing** हे एक तत्त्व आहे जिथे एखाद्या ऑब्जेक्टची योग्यता **कोणत्या methods ला प्रतिक्रिया देते** यावर निर्भर करते, त्याच्या class किंवा type वर नाही — "जर ते बत्तखीसारखे चालते आणि बत्तखीसारखे आवाज करते, तर ते बत्तखी आहे." Ruby मध्ये, तुम्ही हे काळजी करता की एखादी ऑब्जेक्ट *काहीतरी करू शकते* (method आहे), कोणत्या प्रकारची आहे हे नाही. हे inheritance किंवा interfaces शिवाय लवचिक, polymorphic code सक्षम करते.

## तत्त्व: प्रकारापेक्षा वर्तन

```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` **कोणत्याही** ऑब्जेक्ट सह कार्य करते ज्याला `quack` method आहे — `Duck`, `Person`, काहीही. हे type तपासत नाही; हे फक्त method कॉल करते. हे shared inheritance किंवा explicit interfaces शिवाय polymorphism आहे.

## वास्तविक-जगतातील 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
```

## वर्तनासाठी तपासणी (प्रकार नाही)

```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 `respond_to?` (याला हा method आहे का?) `is_a?` (हा प्रकार आहे का?) पेक्षा लवचिकता महत्वाची असल्यास वापरते — **सामर्थ्य, class नाही** वर लक्ष केंद्रित करते.

## हे महत्वाचे का आहे

Duck typing हे Ruby तत्त्व आहे आणि Ruby कसे लवचिकता आणि polymorphism प्राप्त करते याचे परिभाषित वैशिष्ट्य आहे, त्यामुळे हे समजणे महत्वाचे आहे idiomatic Ruby लिहिण्यासाठी.

मूळ कल्पना — की एखाद्या ऑब्जेक्टची योग्यता **कोणते हे करू शकते (त्याचे methods), class/type नाही** यावर निर्भर करते — लवचिक, polymorphic code सक्षम करते *शिवाय* shared inheritance किंवा explicit interfaces आवश्यक असल्याशिवाय (अर्थातच statically-typed languages मध्ये polymorphism साठी common base classes किंवा interfaces आवश्यक आहेत).

हे मुक्तिदायक आणि शक्तिशाली आहे: एक method कोणत्याही ऑब्जेक्ट सह कार्य करते जो आवश्यक methods ला प्रतिक्रिया देते, त्यामुळे तुम्ही कोणतीही ऑब्जेक्ट pass in करू शकता ज्याला "quack" करते — भिन्न classes, custom objects — आणि ते कार्य करते, code पुनः वापरण्यायोग्य आणि अनुकूल बनवते.

Duck typing समजून घेणे Ruby च्या लवचिक, behavior-focused शैलीचे आणि Ruby code **method presence** (`respond_to?`) पेक्षा **type checks** (`is_a?`) वर का अवलंबून आहे हे स्पष्ट करते — capability हे idiomatic Ruby पद्धति आहे class पेक्षा.

हे तत्त्व Ruby च्या Ruby च्या मुबला (जे कोणत्याही ऑब्जेक्ट सह कार्य करतात जो योग्य methods प्रदान करते, `each` किंवा `<<` असलेल्या कोणत्याही गोष्टीप्रमाणे) आणि frameworks च्या लवचिकतेचा अनेक भाग अधोरेखित करते.

Duck typing समजणे — की Ruby वर्तनाची काळजी करते type नाही, interface-free polymorphism सक्षम करते, आणि idiomatic Ruby class पेक्षा capability तपासते — लवचिक, idiomatic Ruby लिहिण्यासाठी महत्वाचे आहे आणि dynamic, behavior-oriented तत्त्वज्ञान समजण्यासाठी जो Ruby ला statically-typed languages पासून वेगळे करते.

हे मूळ संकल्पनात्मक विषय आहे जो Ruby च्या लवचिकतेला कॅप्चर करते आणि dynamic, duck-typed programming समजून घेणे प्रतिबिंबित करणारा वारंवार मुलाखत बिंदू आहे.