Hvordan definerer du Eloquent-relationer?

Question

Accepted Answer

**Eloquent-relationer** modellerer hvordan databasetabeller relaterer sig til hinanden, defineret som metoder på modeller. Laravel understøtter alle almindelige relationtyper — one-to-many, many-to-many, one-to-one og mere — hvilket giver dig elegant, objektorienteret adgang til relaterede data.

## One-to-many (hasMany / belongsTo)

```php
class User extends Model {
    public function posts() {              // a user HAS MANY posts
        return $this->hasMany(Post::class);
    }
}
class Post extends Model {
    public function author() {              // a post BELONGS TO a user (inverse)
        return $this->belongsTo(User::class);
    }
}

// access related data as properties (lazy-loaded)
$user->posts;          // a Collection of the user's Posts
$post->author;          // the Post's User
$user->posts()->where('published', true)->get();   // query the relationship
```

Den mest almindelige relation: en overordnet `hasMany` underordnede, og hver underordnet `belongsTo` den overordnede. Tilgang til relationen som en egenskab returnerer den eller de relaterede modeller.

## Many-to-many (belongsToMany)

```php
class Post extends Model {
    public function tags() {                // posts and tags — many-to-many
        return $this->belongsToMany(Tag::class);   // uses a pivot table (post_tag)
    }
}
$post->tags;                    // the post's tags
$post->tags()->attach($tagId);   // add an association
$post->tags()->detach($tagId);   // remove
$post->tags()->sync([1, 2, 3]);  // set exactly these
```

**Many-to-many** bruger en pivot-tabel (administreret automatisk), med `attach`/`detach`/`sync` til at administrere tilknytninger.

## Andre relationtyper

```php
$this->hasOne(Profile::class);          // one-to-one
$this->hasManyThrough(...);              // has-many through an intermediate model
$this->morphMany(Comment::class, 'commentable');   // POLYMORPHIC (comments on posts OR videos)
```

## Eager loading (undgå N+1!)

```php
// ❌ N+1: a query per post to get each author
$posts = Post::all();
foreach ($posts as $post) { echo $post->author->name; }

// ✅ eager load with with() — fetches authors in ONE extra query
$posts = Post::with('author')->get();
```

Brug `with()` til at **eager-loade** relationer og forhindre N+1-queryproblemet.

## Hvorfor det betyder noget

Eloquent-relationer er essentielle for at arbejde med relationelle data i Laravel — næsten ethvert program har relaterede enheder (brugere og indlæg, indlæg og tags, ordrer og varer), så forståelse af hvordan man definerer og bruger relationer er fundamental daglig viden.

At kende relationtyperne og hvornår man bruger hver — **`hasMany`/`belongsTo`** for one-to-many (den mest almindelige), **`belongsToMany`** for many-to-many (med pivot-tabellen og `attach`/`detach`/`sync`), `hasOne` for one-to-one, og polymorfiske relationer for fleksible tilknytninger — er nødvendigt for at modellere enhver ikke-triviel data og er en af Eloquents mest kraftfulde, elegante funktioner.

Relationer giver dig intuitiv, objektorienteret adgang til relaterede data (`$user->posts`, `$post->author`) uden at skulle skrive joins manuelt, hvilket er en stor produktivitetsfordel.

Kritisk set er forståelse af **eager loading med `with()`** for at forhindre **N+1-queryproblemet** (hvor tilgang til relationer i en løkke udløser en query pr. record — et alvorligt ydelsesspørgsmål) essentiel, da relationer gør N+1-problemer nemme at introducere.

At mestre Eloquent-relationer — definere dem, få adgang til relaterede data og eager-loade for at undgå N+1 — er kernekendskab, der hyppigt bruges, og som understøtter effektiv datamodellering og ydeevne i Laravel-applikationer.