The Eloquent relationship in Laravel is used to connect different database tables through a model to simplify associated data operations. One-to-one relationships such as user and information: the User model uses hasOne (Profile::class), and the Profile model uses belongsTo (User::class). One-to-many relationships such as articles and comments: The Post model uses hasMany(Comment::class), and the Comment model uses belongsTo(Post::class). Many-to-many relationships such as users and roles: both the User and Role models use the belongsToMany() method, and the relationship is managed through intermediate tables. You can add or remove associations using attach() or detach().

Eloquent relationships in Laravel are how you connect different database tables using models. They make it easier to work with related data without writing raw SQL joins every time.

One-to-One Relationships

This is when one record in a table is linked to exactly one record in another table.

For example, a User might have one Profile . To set this up in Eloquent:

• You create two models: User and Profile .
• In the User model, define a method called profile() that returns $this->hasOne(Profile::class);
• In the Profile model, define a method called user() that returns $this->belongsTo(User::class);

By default, Eloquent assumes the foreign key is the model's name in snake_case plus _id , like user_id .

You can then do things like:

 $user = User::find(1);
echo $user->profile->bio;

This makes it easy to access related data without manually querying each time.

One-to-Many Relationships

This is when one record has many related records — like a Post having many Comments .

To set this up:

• The Comment model should belong to a Post .
• The Post model should define a method like comments() that returns $this->hasMany(Comment::class);

Then you can fetch all comments for a post easily:

 $post = Post::find(5);
foreach ($post->comments as $comment) {
    echo $comment->text;
}

And if a comment has a post_id , you can go the other way too:

 $comment = Comment::find(1);
echo $comment->post->title;

It's pretty common to use this for things like blog posts, orders per customer, etc.

Many-to-Many Relationships

This is when multiple records in one table related to multiple records in another — like Users belonging to multiple Roles , or Posts connected to many Tags .

To handle this, you need a pivot table (like role_user or tag_post ). In Eloquent:

• A User model would have a roles() method returning $this->belongsToMany(Role::class);
• And a Role model would have a users() method doing the same back.

Then you can grab related data like:

 $user = User::find(1);
foreach ($user->roles as $role) {
    echo $role->name;
}

You can also attach or detach relationships:

• Attach: $user->roles()->attach($roleId);
• Detach: $user->roles()->detach($roleId);

This is super useful when dealing with tags, permissions, categories, and more.

That's the core idea behind these three Eloquent relationships. They're not hard once you see how they map real-world connections into code — just remember which model owns the foreign key and how the methods point to each other.

The above is the detailed content of What are Eloquent relationships (one-to-one, one-to-many, many-to-many)?. For more information, please follow other related articles on the PHP Chinese website!