Vad är traits och när använder du dem?

Question

Accepted Answer

En **trait** är en mekanism för att **återanvända kod över flera klasser** som inte är relaterade genom arv. Eftersom PHP endast tillåter enkelt arv, ger traits ett sätt att dela metoder (och egenskaper) horisontellt — en form av "kompositionell" kodåteranvändning, ungefär som mixins.

## Problemet som traits löser

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

## Definiera och använda en 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
```

En trait är en samling metoder/egenskaper. En klass `use`:ar en eller flera traits för att **blanda in** deras medlemmar — få funktionaliteten utan att ärva från en gemensam förälder.

## Traits jämfört med arv och 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.
```

## Konfliktlösning

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

När två traits definierar samma metod gör PHP tvungen att lösa konflikten explicit.

## Varför det spelar roll

Traits är en viktig PHP-funktion för **kodåteranvändning över orelaterade klasser**, och löser en verklig begränsning: eftersom PHP endast tillåter enkelt arv, ger traits horisontell återanvändning (mixins) för att dela gemensam funktionalitet — loggning, tidsstämplar, soft-deletes, serialiseringshjälpare — över klasser som inte delar en förälder.

Det är värdefullt att förstå dem eftersom de används flitigt i PHP-ramverk (Laravels Eloquent använder traits utförligt för modellbeteenden som `SoftDeletes`, `HasFactory`), så du kommer ständigt att stöta på och använda dem.

Att veta hur traits skiljer sig från arv (återanvändning utan en is-a-relation) och från interfaces (traits ger faktisk *implementering*/kod, medan interfaces endast definierar ett *avtal*/signaturer — och de två kombineras ofta: ett interface deklarerar möjligheten, en trait tillhandahåller den delade implementeringen) är nyckeln till att använda dem lämpligt.

Traits möjliggör DRY, kompositionella design som enkelt arv ensamt inte kan, vilket gör dem praktiska, ofta förekommande kunskaper för både att skriva återanvändbar PHP-kod och för att förstå de ramverk som bygger på dem. (Försiktigheten: överanvändning av traits kan dölja var beteendet kommer från, så använd dem för verklig tvärgående återanvändning, inte som standard.)