Ruby માં ડક ટાઈપિંગ શું છે?

Question

Accepted Answer

**ડક ટાઈપિંગ** એ એક સિદ્ધાંત છે જ્યાં ઑબ્જેક્ટની યોગ્યતા તેના વર્ગ અથવા પ્રકાર દ્વારા નહીં, પરંતુ **તે કયા પદ્ધતિઓને સમર્થન આપે છે** તેના દ્વારા નક્કી થાય છે — "જો તે બતકની માફક ચાલે અને બતક સાથે કયૂક કરે, તો તે બતક છે." Ruby માં, તમને ધ્યાન છે કે એક ઑબ્જેક્ટ *કોઈ કામ કરી શકે છે* (પદ્ધતિ છે), તેનો પ્રકાર શું છે તે નહીં. આ વારસગતી અથવા ઇન્ટરફેસ વિના લવચક, બહુરૂપી કોડ સક્ષમ કરે છે.

## સિદ્ધાંત: પ્રકાર પર વર્તન

```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` પદ્ધતિ છે — `Duck`, `Person`, કંઈપણ. તે પ્રકાર તપાસતું નથી; તે માત્ર પદ્ધતિને બોલાવે છે. આ સહભાગી વારસગતી અથવા સ્પષ્ટ ઇન્ટરફેસ વિના બહુરૂપતા છે.

## વાસ્તવિક-વિશ્વ ડક ટાઈપિંગ

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

થીમાટીક Ruby `respond_to?` (શું તેની પાસે આ પદ્ધતિ છે?) `is_a?` (શું તે આ પ્રકાર છે?) ઉપર ઉપયોગ કરે છે જ્યારે લવચકતા મહત્વપૂર્ણ હોય છે — **ક્ષમતા, વર્ગ નહીં** પર ધ્યાન કેન્દ્રિત કરીને.

## તે શા માટે મહત્વપૂર્ણ છે

ડક ટાઈપિંગ એક મૌલિક Ruby સિદ્ધાંત છે અને Ruby કીવી લવચકતા અને બહુરૂપતા પ્રાપ્ત કરવાની રીતની વ્યાખ્યાયિત લાક્ષણિકતા છે, તેથી તેને સમજવું મહત્વપૂર્ણ છે પ્રાતિક Ruby લખવા માટે.

મૂલ વિચાર — કે એક ઑબ્જેક્ટની યોગ્યતા **તે શું કરી શકે છે (તેની પદ્ધતિઓ), તેના વર્ગ/પ્રકાર નહીં** દ્વારા નક્કી થાય છે — લવચક, બહુરૂપી કોડ *વિના* સહભાગી વારસગતી અથવા સ્પષ્ટ ઇન્ટરફેસ (સ્થિતિ-પ્રકારના ભાષાઓથી અલગ જ્યાં બહુરૂપતાને સામાન્ય આધાર વર્ગો અથવા ઇન્ટરફેસની જરૂર હોય છે) સક્ષમ કરે છે.

આ મુક્તિધર્મક અને શક્તિશાળી છે: એક પદ્ધતિ કોઈપણ ઑબ્જેક્ટ સાથે કાર્ય કરે છે જે જરૂરી પદ્ધતિઓને જવાબ આપે છે, તેથી તમે કોઈપણ વસ્તુ પસ કરી શકો જે "કયૂક" કરે છે — વિવિધ વર્ગો, કસ્ટમ ઑબ્જેક્ટ્સ — અને તે કાર્ય કરે છે, કોડને પુનઃવપરાશ્મય અને સુસંગત બનાવે છે.

ડક ટાઈપિંગને સમજવું Ruby ની લવચક, વર્તન-કેન્દ્રિત શૈલીને સમજાવે છે અને શા માટે Ruby કોડ સામાન્ય રીતે **પ્રકાર તપાસ** (`is_a?`) કરવાને બદલે **પદ્ધતિ અસ્તિત્વ** (`respond_to?`) પર આધાર રાખે છે — વર્ગ પર ક્ષમતા પર ધ્યાન કેન્દ્રિત કરવું પ્રાતિક Ruby અભિગમ છે.

આ સિદ્ધાંત Ruby ની કમનીયતા અને તેની લાઇબ્રેરી અને ફ્રેમવર્ક્સ (જે કોઈપણ વસ્તુ સાથે કાર્ય કરે છે જે યોગ્ય પદ્ધતિઓ પ્રદાન કરે છે, જેમ કે કોઈપણ `each` અથવા `<<` સાથે) ની લવચકતার બહુ બધું આધાર આપે છે.

ડક ટાઈપિંગને સમજવું — Ruby વર્તન વિશે પણ્યું નથી પ્રકાર, ઇન્ટરફેસ-મુક્ત બહુરૂપતા સક્ષમ કરીને, અને પ્રાતિક Ruby વર્ગ કરતાં ક્ષમતા તપાસે છે — લવચક, પ્રાતિક Ruby લખવા માટે અને ગતિશીલ, વર્તન-લક્ષી તત્વશાસ્ત્રને સમજવા માટે મહત્વપૂર્ણ છે જે Ruby ને સ્થિતિ-પ્રકારના ભાષાઓથી અલગ કરે છે.

યह एक મુખ્ય સંકલ્પીય વિષય છે જે Ruby ની લવચક ડિઝાઇન ને કબજે કરે છે અને એક વારંવાર साক્ષાત્કાર બિંદુ છે જે ગતિશીલ, ડક-ટાઈપ કરેલ પ્રોગ્રામિંગ સમજવા પ્રતિબિંબિત કરે છે.