Hvad er traits, og hvornår bruger du dem?

Question

Accepted Answer

En **trait** er en mekanisme til **genbrug af kode på tværs af flere klasser**, der ikke er relateret gennem arv. Da PHP kun tillader single inheritance, giver traits en måde at dele metoder (og properties) horisontalt — en form for "kompositorisk" kodegenbrug, 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.
```

## Definition og brug af 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 er en samling af metoder/properties. En klasse `use`r en eller flere traits for at **blande** deres medlemmer ind — og får funktionaliteten uden at arve fra en fælles forælder.

## Traits vs arv 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.
```

## 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 to traits definerer den samme metode, tvinger PHP dig til at løse konflikten eksplicit.

## Hvorfor det betyder noget

Traits er en vigtig PHP-feature til **kodegenbrug på tværs af urelaterede klasser**, og løser en reel begrænsning: da PHP kun tillader single inheritance, giver traits horisontalt genbrug (mixins) til at dele fælles funktionalitet — logging, timestamps, soft-deletes, serialiseringshjælpere — på tværs af klasser, der ikke deler en forælder.

Forståelse af dem er værdifuld, fordi de er udbredt i PHP-frameworks (Laravels Eloquent bruger traits omfattende til modeladfærd som `SoftDeletes`, `HasFactory`), så du vil konstant møde og bruge dem.

At vide, hvordan traits adskiller sig fra arv (genbrug uden et is-a-forhold) og fra interfaces (traits giver faktisk *implementering*/kode, mens interfaces kun definerer en *kontrakt*/signaturer — og de to kombineres ofte: et interface erklærer evnen, en trait leverer den delte implementering) er nøglen til at bruge dem hensigtsmæssigt.

Traits aktiverer DRY, kompositoriske designs, som single inheritance alene ikke kan, hvilket gør dem praktiske, hyppigt påtrufne viden både til at skrive genanvendeligt PHP-kode og til at forstå de frameworks, der er bygget omkring dem. (Forbehældet: overdreven brug af traits kan tilsløre, hvor adfærd kommer fra, så brug dem til ægte tværgående genbrug, ikke som en standard.)