Traits क्या हैं और आप उन्हें कब उपयोग करते हैं?

Question

Accepted Answer

**Trait** एक तंत्र है जो **कई वर्गों में कोड का पुनः उपयोग** करता है जो विरासत द्वारा संबंधित नहीं हैं। चूंकि PHP केवल एकल विरासत की अनुमति देता है, traits विधियों (और गुणों) को क्षैतिज रूप से साझा करने का एक तरीका प्रदान करते हैं — एक प्रकार का "संरचनात्मक" कोड पुनः उपयोग, mixins की तरह।

## समस्या जिसे traits हल करते हैं

```text
PHP has single inheritance — a class can extend only ONE parent. But you often want
to share the SAME methods across unrelated classes (e.g. logging, timestamps).
Duplicating the code is bad; traits let you reuse it without inheritance.
```

## Trait को परिभाषित और उपयोग करना

```php
<?php
trait Timestampable {
    private ?DateTime $createdAt = null;

public function setCreatedAt(): void {
        $this->createdAt = new DateTime();
    }
    public function getCreatedAt(): ?DateTime {
        return $this->createdAt;
    }
}

trait Loggable {
    public function log(string $msg): void {
        echo "[" . static::class . "] $msg";
    }
}

// a class can USE MULTIPLE traits — their methods become part of the class
class Article {
    use Timestampable, Loggable;     // mix in BOTH traits' methods
}

$a = new Article();
$a->setCreatedAt();    // from Timestampable
$a->log("created");     // from Loggable
```

एक trait विधियों/गुणों का एक बंडल है। एक वर्ग `use` एक या अधिक traits को उनके सदस्यों को **मिक्स** करने के लिए — एक सामान्य माता-पिता से विरासत प्राप्त किए बिना कार्यक्षमता प्राप्त करता है।

## Traits vs विरासत vs interfaces

```text
Inheritance (extends) → single parent, "is-a", inherits implementation
Interface → a CONTRACT (signatures only, no code), multiple allowed
Trait → reusable IMPLEMENTATION (actual code), multiple allowed, NO contract
→ Interfaces say WHAT a class can do; traits provide HOW (shared code).
  They're often used together: implement an interface, use a trait for the impl.
```

## Conflict समाधान

```php
class X {
    use TraitA, TraitB {
        TraitA::hello insteadof TraitB;   // if both define hello(), pick TraitA's
        TraitB::hello as helloB;           // alias TraitB's version
    }
}
```

जब दो traits एक ही विधि को परिभाषित करते हैं, PHP आपको conflict को स्पष्ट रूप से हल करने के लिए बाध्य करता है।

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

Traits **असंबंधित वर्गों में कोड पुनः उपयोग** के लिए एक महत्वपूर्ण PHP विशेषता है, एक वास्तविक सीमा को हल करते हुए: क्योंकि PHP केवल एकल विरासत की अनुमति देता है, traits क्षैतिज पुनः उपयोग (mixins) प्रदान करते हैं सामान्य कार्यक्षमता साझा करने के लिए — logging, timestamps, soft-deletes, serialization helpers — उन वर्गों में जो एक माता-पिता साझा नहीं करते।

उन्हें समझना महत्वपूर्ण है क्योंकि PHP frameworks में व्यापक रूप से उपयोग किए जाते हैं (Laravel के Eloquent traits का व्यापक रूप से मॉडल व्यवहार के लिए उपयोग किया जाता है जैसे `SoftDeletes`, `HasFactory`), इसलिए आप उनका लगातार सामना करेंगे और उपयोग करेंगे।

जानना कि traits विरासत से कैसे भिन्न हैं (is-a संबंध के बिना पुनः उपयोग) और interfaces से (traits वास्तविक *कार्यान्वयन*/कोड प्रदान करते हैं, जबकि interfaces केवल एक *अनुबंध*/हस्ताक्षर परिभाषित करते हैं — और दोनों अक्सर संयुक्त होते हैं: एक interface क्षमता घोषित करता है, एक trait साझा कार्यान्वयन प्रदान करता है) उन्हें सही तरीके से उपयोग करने के लिए महत्वपूर्ण है।

Traits DRY और compositional designs को सक्षम करते हैं जो अकेले एकल विरासत नहीं कर सकते, उन्हें पुनः उपयोग योग्य PHP कोड लिखने और उनके चारों ओर निर्मित frameworks को समझने दोनों के लिए व्यावहारिक, अक्सर सामने आने वाले ज्ञान बनाते हैं। (चेतावनी: traits का अत्यधिक उपयोग यह अस्पष्ट कर सकता है कि व्यवहार कहां से आ रहा है, इसलिए उन्हें वास्तविक cross-cutting पुनः उपयोग के लिए उपयोग करें, न कि डिफ़ॉल्ट के रूप में।)