Bagaimanakah anda mentakrifkan hubungan (relationship) Eloquent?

Question

Accepted Answer

**Hubungan Eloquent** memodelkan cara jadual pangkalan data berkaitan, ditakrifkan sebagai kaedah pada model. Laravel menyokong semua jenis hubungan lazim — satu-ke-banyak (one-to-many), banyak-ke-banyak (many-to-many), satu-ke-satu (one-to-one), dan banyak lagi — memberi anda akses yang elegan dan berorientasikan objek kepada data berkaitan.

## Satu-ke-banyak (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
```

Hubungan yang paling lazim: satu induk `hasMany` anak, dan setiap anak `belongsTo` induk. Mengakses hubungan sebagai property memulangkan model berkaitan.

## Banyak-ke-banyak (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
```

**Banyak-ke-banyak** menggunakan jadual pivot (diurus secara automatik), dengan `attach`/`detach`/`sync` untuk mengurus perkaitan.

## Jenis hubungan lain

```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 (elakkan 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();
```

Gunakan `with()` untuk **eager-load** hubungan dan mencegah masalah query N+1.

## Mengapa ia penting

Hubungan Eloquent adalah penting untuk bekerja dengan data berkaitan (relational) dalam Laravel — hampir setiap aplikasi mempunyai entiti berkaitan (pengguna dan post, post dan tag, pesanan dan item), jadi memahami cara mentakrifkan dan menggunakan hubungan adalah pengetahuan harian asas.

Mengetahui jenis hubungan dan bila menggunakan setiap satu — **`hasMany`/`belongsTo`** untuk satu-ke-banyak (yang paling lazim), **`belongsToMany`** untuk banyak-ke-banyak (dengan jadual pivot dan `attach`/`detach`/`sync`), `hasOne` untuk satu-ke-satu, dan hubungan polimorfik untuk perkaitan yang fleksibel — adalah perlu untuk memodelkan sebarang data bukan remeh dan merupakan salah satu ciri Eloquent yang paling berkuasa dan elegan.

Hubungan memberi anda akses yang intuitif dan berorientasikan objek kepada data berkaitan (`$user->posts`, `$post->author`) tanpa menulis join secara manual, yang merupakan manfaat produktiviti utama.

Secara kritikal, memahami **eager loading dengan `with()`** untuk mencegah **masalah query N+1** (di mana mengakses hubungan dalam gelung mencetuskan satu query setiap rekod — isu prestasi yang teruk) adalah penting, kerana hubungan menjadikan masalah N+1 mudah diperkenalkan.

Menguasai hubungan Eloquent — mentakrifkannya, mengakses data berkaitan, dan eager-load untuk mengelakkan N+1 — adalah pengetahuan teras yang kerap digunakan yang mendasari pemodelan data dan prestasi yang berkesan dalam aplikasi Laravel.