Using Eloquent Query Scopes in Laravel.

Eloquent query scope improves code clarity and reusability by encapsulating common query logic. 1. The local scope is defined with methods starting with scope, such as scopeActive() is used to filter enabled users; 2. The dynamic scope supports parameter passing, such as scopeStatus($status) to achieve flexible state filtering; 3. The global scope is automatically applied to all queries, suitable for data isolation but needs to be used with caution; 4. Multiple scopes can be combined in chains to enhance semantic expression and maintenance; 5. Complex queries can be centrally processed through conditional judgments to improve flexibility.

In Laravel, Eloquent Query Scopes is a very practical but often underestimated feature. It can help you encapsulate commonly used query logic, making the code clearer and more reusable. If you often write duplicate where conditions or want to organize query logic in your model, using Query Scopes is a good choice.

What is Eloquent query scope?

Simply put, the Eloquent query scope is a method defined in the model to add some common query conditions. You can understand it as a "preset filter". Every time this scope is called, the query conditions you defined will be automatically added.

For example, if you want to filter out all users with status enabled, you can define an active() scope, so that when checking active users in the future, you don’t have to write where('status', 1) every time.

How to define and use Local Scopes

Defining a local scope is simple, you just need to create a method starting with scope in the model.

 public function scopeActive($query)
{
    return $query->where('status', 1);
}

Then you can use it like this:

 User::active()->get();

Note: The first parameter to the scope must be $query , representing the current query builder.

Common application scenarios include:

• Filter published content: scopePublished()
• Filter the records marked as soft deleted: scopeNotDeleted()
• Query by time range: scopeLastWeek()

How to use Parameterized Scopes

Sometimes you want the scope to receive parameters. For example, not only to check the user with "status 1", but also want to pass in different status values.

This can be done at this time:

 public function scopeStatus($query, $status)
{
    return $query->where('status', $status);
}

Pass parameters when using:

 User::status(2)->get();

This method is very suitable for scenarios where flexible value transfer is required, such as search by keyword, pagination offset, time interval, etc.

What should I pay attention to when using Global Scopes?

In addition to local scopes, Laravel supports global scopes, which are automatically applied every time the model is queryed. Suitable for unified data isolation, such as only access to the current tenant's data in a multi-tenant system.

To use global scope, you need to create a class to implement Illuminate\Database\Eloquent\Scope interface, and then call addGlobalScope() in booted() method of the model.

 protected static function booted()
{
    static::addGlobalScope('tenant', function ($builder) {
        $builder->where('tenant_id', tenant_current_id());
    });
}

However, it should be noted that once the global scope is added, it cannot be easily removed . If you want to bypass it temporarily, you can only cancel it by using withoutGlobalScopes() method.

A little trick: combine multiple scopes

You can combine multiple scopes like building blocks, such as:

 User::active()->verified()->recent()->get();

Each scope returns a query constructor instance, so it can be called in a chain. This writing is not only semantic, but also easy to test and maintain.

In addition, if a query is particularly complex, multiple conditional judgments can be encapsulated in one scope, such as:

 public function scopeFilter($query, $filters)
{
    if (! empty($filters['status'])) {
        $query->where('status', $filters['status']);
    }

    if (! empty($filters['search'])) {
        $query->where('name', 'like', '%' . $filters['search'] . '%');
    }
}

In this way, the filter parameters transmitted from the front end can be processed centrally.

Basically that's it. Query Scopes is not complicated, but is very useful in actual development. Using it rationally can make your model layer cleaner and easier to write consistent query logic.

The above is the detailed content of Using Eloquent Query Scopes in Laravel.. For more information, please follow other related articles on the PHP Chinese website!