ਰੂਬੀ ਵਿੱਚ ਡੱਕ ਟਾਈਪਿੰਗ ਕੀ ਹੈ?

Question

Accepted Answer

**ਡੱਕ ਟਾਈਪਿੰਗ** ਇੱਕ ਸਿਧਾਂਤ ਹੈ ਜਿੱਥੇ ਇੱਕ ਆਬਜੈਕਟ ਦੀ ਅਨੁਕੂਲਤਾ **ਉਹ ਤੈਨੂੰ ਕਿਹੜੀਆਂ ਮੈਥਡਾਂ ਦੇ ਜਵਾਬ ਦਿੰਦਾ ਹੈ** ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਨਾ ਕਿ ਇਸ ਦੀ ਕਲਾਸ ਜਾਂ ਕਿਸਮ ਦੁਆਰਾ — "ਜੇ ਇਹ ਆਸ ਵਾਂਗ ਚਲਦਾ ਹੈ ਅਤੇ ਆਸ ਵਾਂਗ ਬੋਲਦਾ ਹੈ, ਤਾਂ ਇਹ ਆਸ ਹੈ।" ਰੂਬੀ ਵਿੱਚ, ਤੁਸੀਂ ਉਸ ਗੱਲ ਦੀ ਪਰਵਾਹ ਕਰਦੇ ਹੋ ਕਿ ਇੱਕ ਆਬਜੈਕਟ *ਕੁਝ ਕਰ ਸਕਦਾ ਹੈ* (ਮੈਥਡ ਰੱਖਦਾ ਹੈ), ਨਾ ਕਿ ਇਹ ਕਿਸ ਕਿਸਮ ਦਾ ਹੈ। ਇਹ ਵਿਰਾਸਤ ਜਾਂ ਇੰਟਰਫੇਸ ਤੋਂ ਬਿਨਾ ਲਚਕਦਾਰ, ਬਹੁ-ਰੂਪੀ ਕੋਡ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ।

## ਸਿਧਾਂਤ: ਆਚਰਣ ਕਿਸਮ ਤੋਂ ਤੋਂ ਪਹਲਾਂ

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

ਅਲੋਪਨੀ ਰੂਬੀ `respond_to?` ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ (ਕੀ ਇਸ ਕੋਲ ਇਹ ਮੈਥਡ ਹੈ?) `is_a?` ਦੇ ਬਜਾਏ (ਕੀ ਇਹ ਇਹ ਕਿਸਮ ਹੈ?) ਜਦੋਂ ਲਚਕਤਾ ਮਾਇਨੇ ਰਖਦੀ ਹੈ — **ਸਮਰੱਥਾ, ਕਲਾਸ ਨਹੀਂ** ਉੱਤੇ ਧਿਆਨ ਦਿੰਦੇ ਹੋਏ।

## ਇਹ ਮਾਇਨੇ ਕਿਉਂ ਰਖਦਾ ਹੈ

ਡੱਕ ਟਾਈਪਿੰਗ ਇੱਕ ਬੁਨਿਆਦੀ ਰੂਬੀ ਸਿਧਾਂਤ ਹੈ ਅਤੇ ਇਹ ਇੱਕ ਪਰਿਭਾਸ਼ਾਤਮਕ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ ਕਿ ਰੂਬੀ ਲਚਕਤਾ ਅਤੇ ਬਹੁ-ਰੂਪਤਾ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ, ਇਸਲਈ ਇਸ ਨੂੰ ਸਮਝਣਾ ਆਲੋਪਨੀ ਰੂਬੀ ਲਿਖਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਮੂਲ ਧਾਰਣਾ — ਕਿ ਇੱਕ ਆਬਜੈਕਟ ਦੀ ਅਨੁਕੂਲਤਾ **ਇਹ ਕੀ ਕਰ ਸਕਦਾ ਹੈ (ਇਸ ਦੀਆਂ ਮੈਥਡਾਂ), ਨਾ ਕਿ ਇਸ ਦੀ ਕਲਾਸ/ਕਿਸਮ** ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ — ਸਾਂਝੀ ਵਿਰਾਸਤ ਜਾਂ ਸਪਸ਼ਟ ਇੰਟਰਫੇਸ ਦੀ ਲੋੜ *ਤੋਂ ਬਿਨਾ* ਲਚਕਦਾਰ, ਬਹੁ-ਰੂਪੀ ਕੋਡ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ (ਸਥਿਰ-ਕਿਸਮ ਵਾਲੀਆਂ ਭਾਸ਼ਾਵਾਂ ਦੇ ਉਲਟ ਜਿੱਥੇ ਬਹੁ-ਰੂਪਤਾ ਨੂੰ ਸਾਂਝੀ ਬੇਸ ਕਲਾਸਾਂ ਜਾਂ ਇੰਟਰਫੇਸ ਦੀ ਲੋੜ ਹੈ)।

ਇਹ ਮੁਕਤੀਵਾਦੀ ਅਤੇ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ: ਇੱਕ ਮੈਥਡ ਕਿਸੇ ਵੀ ਆਬਜੈਕਟ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ ਜੋ ਲੋੜੀਂਦੀ ਮੈਥਡ ਦੇ ਜਵਾਬ ਦਿੰਦਾ ਹੈ, ਇਸਲਈ ਤੁਸੀਂ ਕਮੀ ਕੁਝ ਵੀ ਪਾਸ ਕਰ ਸਕਦੇ ਹੋ ਜੋ "ਬਿੱਕ" — ਵੱਖ-ਵੱਖ ਕਲਾਸਾਂ, ਕਸਟਮ ਆਬਜੈਕਟ — ਅਤੇ ਇਹ ਸਿਰਫ ਕੰਮ ਕਰਦਾ ਹੈ, ਕੋਡ ਨੂੰ ਮੁੜ ਵਰਤਣਯੋਗ ਅਤੇ ਅਨੁਕੂਲਨੀ ਬਣਾਉਂਦੇ ਹੋਏ।

ਡੱਕ ਟਾਈਪਿੰਗ ਨੂੰ ਸਮਝਣਾ ਰੂਬੀ ਦੇ ਲਚਕਦਾਰ, ਆਚਰਣ-ਕੇਂਦ੍ਰਿਤ ਸ਼ੈਲੀ ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ ਅਤੇ ਇਹ ਵਿਸ਼ਾ ਕਿ ਰੂਬੀ ਕੋਡ ਆਮ ਤੌਰ ਤੇ **ਕਿਸਮ ਚੈਕ** (`is_a?`) ਦੀ ਬਜਾਏ **ਮੈਥਡ ਮੌਜੂਦਗੀ** (`respond_to?`) 'ਤੇ ਨਿਰਭਰ ਕਰਨ ਕਿਉਂ ਹੈ — ਸਮਰੱਥਾ 'ਤੇ ਧਿਆਨ ਦਿੰਦੇ ਹੋਏ ਅਨੁਮਾਨਾਂ ਦੀ ਰੂਬੀ ਪ੍ਰਣਾਲੀ ਹੈ।

ਇਹ ਸਿਧਾਂਤ ਰੂਬੀ ਦੀ ਬਹੁਤੀ ਖੂਬਸੂਰਤੀ ਅਤੇ ਇਸ ਦੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਫਰੇਮਵਰਕ ਦੀ ਲਚਕਤਾ (ਜੋ ਕਮੀ ਵੀ ਚੀਜ਼ ਨਾਲ ਕੰਮ ਕਰਦੀ ਹੈ ਜੋ ਸਹੀ ਮੈਥਡਾਂ ਨੂੰ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ, ਜਿਵੇਂ `each` ਜਾਂ `<<` ਨਾਲ ਕਮੀ ਕੁਝ ਵੀ) ਨੂੰ ਦੱਸਦਾ ਹੈ।

ਡੱਕ ਟਾਈਪਿੰਗ ਨੂੰ ਸਮਝਣਾ — ਕਿ ਰੂਬੀ ਆਚਰਣ ਨੂੰ ਕਿਸਮ ਦੀ ਪਰਵਾਹ ਕਰਦਾ ਹੈ, ਇੰਟਰਫੇਸ-ਮੁਕਤ ਬਹੁ-ਰੂਪਤਾ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੇ ਹੋਏ, ਅਤੇ ਜੋ ਆਲੋਪਨੀ ਰੂਬੀ ਸਮਰੱਥਾ ਦੀ ਬਜਾਏ ਕਲਾਸ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ — ਲਚਕਦਾਰ, ਆਲੋਪਨੀ ਰੂਬੀ ਲਿਖਣ ਅਤੇ ਗਤੀਸ਼ੀਲ, ਡੱਕ-ਕਿਸਮ ਵਾਲੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਦੀ ਦਰਸ਼ਨ ਨੂੰ ਸਮਝਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਜੋ ਰੂਬੀ ਨੂੰ ਸਥਿਰ-ਕਿਸਮ ਵਾਲੀਆਂ ਭਾਸ਼ਾਵਾਂ ਤੋਂ ਵੱਖ ਕਰਦਾ ਹੈ।

ਇਹ ਇੱਕ ਮੁੱਖ ਧਾਰਣਾ ਵਾਲਾ ਵਿਸ਼ਾ ਹੈ ਜੋ ਰੂਬੀ ਦੀ ਲਚਕਦਾਰ ਡਿਜ਼ਾਈਨ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਅਤੇ ਇਸ ਸਾਹਮਣੇ ਇੰਟਰਵਿ ਦਾ ਬਿੰਦੂ ਹੈ ਜੋ ਗਤੀਸ਼ੀਲ, ਡੱਕ-ਕਿਸਮ ਵਾਲੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਨੂੰ ਸਮਝਣ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।