Laravel - Eloquent "Has", "With", "WhereHas" - What do they mean?
Stefan Izdrail
Founder & Senior Architect · 2026-06-29
Title: Clarifying Laravel Eloquent Relationship Methods: Understanding "Has", "With" and "WhereHas"
Introduction
Laravel is an incredibly powerful PHP framework, which employs a beautiful syntax for creating applications with ease. Its ORM (Object-Relational Mapper), called Eloquent, offers a simple yet robust solution to interacting with databases. But, navigating its relationship functionality can be a little tricky at times - especially when dealing with methods like `has`, `with`, and `WhereHas`. This blog post aims to provide you with a comprehensive understanding of these methods from a developer's perspective, as well as code examples and best practices that will make these concepts clearer.
1. Understanding Laravel Eloquent Relationship Methods
Before jumping into the details, let us first understand what relationship methods do in general - they allow you to query the data of related or associated models without performing multiple queries. This is incredibly useful when dealing with complex applications that require multiple database interactions.
2. "Has"
The `has` method is used to determine if a given model has any records associated with another model through a relationship. It returns either true (if there are related records) or false (if there aren't). Let us see an example:
```php
// App/User.php
class User extends Model
{
public function posts() { return $this->hasMany('App\Post'); }
}
// Check if a user has any published posts
$user = User::find(1); // Assuming 'id' is the primary key
if ($user->posts()->where('published', true)->count()) {
echo "User 1 has at least one published post.";
}
```
In this example, we defined a relationship between `User` and `Post` where each `User` can have many posts. The code snippet checks if the user with ID 1 has any published posts. If the count of the result is greater than zero, then it prints out that they do have at least one published post.
3. "With"
The `with` method allows you to eager load related models when retrieving a collection of parent models. This means that instead of loading all records individually in separate queries, you can fetch them all together. It also improves performance by preventing N+1 queries and reducing the number of database calls. Let's see an example:
```php
// App/User.php
class User extends Model
{
public function posts() { return $this->hasMany('App\Post'); }
public function relatedUsersWithPosts($posts)
{
return $this->with(['posts' => $post])->get();
}
}
```
The above code defines a method that searches for users associated with a given collection of posts. The `with` method is used to include the related 'posts' in the result, loading them simultaneously instead of separately.
4. "WhereHas"
Lastly, let's discuss the `whereHas` method, which filters the results based on the conditions within the relationship. It allows you to filter a collection or query by checking whether a specific record exists inside the related models. Here is an example:
```php
// App/User.php
class User extends Model
{
public function posts() { return $this->hasMany('App\Post'); }
}
$usersWithPublishedPosts = User::whereHas('posts', function ($query) {
$query->where('published', true);
})->get();
```
In this example, we once again define a relationship between `User` and `Post`. We then use the `whereHas` to filter users based on whether they have any published posts. The call returns a collection of all these users.
Conclusion
Understanding Laravel's relationship methods can be crucial for developing efficient and well-structured applications. By leveraging their power, you can simplify complex database interactions and improve your application's performance. Always remember that the key to effective coding is to maintain a clean codebase. Use these methods where necessary without overusing them. Happy coding!
Resources:
1. https://laravelcompany.com/blog/laravel-eloquent-relationships-made-easy
2. https://laracasts.com/series/laravel-5-fundamentals/episodes/6
3. https://laravel.com/docs/7.x/eloquent-relationships#querying-relationship-existence