Useful Tips and Tricks for Laravel

Laravel is one of the most widely used PHP frameworks in the world. Its simplicity, ease of use, and robust features have made it a popular choice for developers who want to create high-quality web applications with ease. However, even seasoned Laravel developers can sometimes struggle with certain aspects of the framework.

The Laravel tips and tricks tutorial covers a variety of advanced techniques for developers using the Laravel PHP framework to build more efficient and effective web applications. Let’s get started!

Make your code more elegant using Eloquent

Local query scopes

In our project, we have several conditions that need to be met. Consider this query, for example:


$admins = User::where('active', '=', 1)->where('is_admin', '=', 1)->get();


To achieve this, we can utilize Local Query Scopes to improve code readability and reduce repetition. As an example, we can create the following functions in our model:


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

public function scopeAdmin($query)
{
return $query->where('is_admin', '=', 1);
}


Now, our original query would look like this:


$admins = User::active()->admin()->get();


2. Global query scopes

The global query scope allows you to apply a constraint to all queries on a model by default.

Let’s create a new global scope class.


<?php

namespace App\Scopes;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Scope;

class ActiveScope implements Scope
{
public function apply(Builder $builder, Model $model)
{
$builder->where('active', '=', 1);
}
}


Now, we will add scope to our model. So that when we use Eloquent ORM, it applies automatically.


<?php

namespace App;

use Illuminate\Database\Eloquent\Model;
use App\Scopes\ActiveScope;

class User extends Model
{
protected static function boot()
{
parent::boot();

static::addGlobalScope(new ActiveScope);
}
}
How to use
$users = User::all();
// in the above query we will get only active users.

$users = User::withoutGlobalScope(ActiveScope::class)->get();
// In the above query we will get all users.


Model boot() method

The static boot() method is automatically executed when a model is instantiated, making it an ideal location to add behavior or event bindings. In this case, setting the default value of the is_admin field during the creation of the model object is a suitable example. However, the sentence structure could be improved by breaking it into two or more sentences for better readability.


<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
self::creating(function($model) {
$model->is_admin = 0;
});
}


is() method in Laravel

Determines whether two models belong to the same table and share identical IDs.


$user = User::find(1);
$sameUser = User::find(1);
$diffUser = User::find(2);
$user->is($sameUser); // true
$user->is($diffUser); // false


Replicate a model

To replicate a model in Laravel, you can use the replicate() method, which creates a new instance of the model with the same details as the original. Additionally, you can modify any field values before saving the new instance to the database.


$user = User::find(1);
$newUser = $user->replicate();
$newUser->save();


Select attributes in find() method

When using the find() method in Laravel, you can select specific attributes to retrieve by passing them as the second argument.


$user = User::find(1, ['name', 'status']);


Expressive “where” Syntax

You can make this query more expressive like below, by suffixing the attribute to the where clause itself.


$users = User::whereStatus('active')->get();


Model properties

There are some properties of an Eloquent model:


<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class User extends Model
{
protected $table = 'users'; // users table is associated with model we can change here.

protected $connection = 'sqlite'; // we can customize our database connection.

protected $fillable = ['name', 'email', 'password']; // The attributes that are mass assignable.

protected $dates = ['created_at', 'deleted_at']; // attributes that should be mutated to dates so we can change format like format('M d Y')

protected $appends = ['field_name']; // we can add additional field to json response

protected $primaryKey = 'uuid'; // which field will be primary key of the model

public $incrementing = false; // disable auto-increment id for the model!

protected $perPage = 30; // we can override default 15 pagination using $perPage variable

const CREATED_AT = 'created';

const UPDATED_AT = 'updated'; // we can change field name of created_at and updated_at.

public $timestamps = false; // disable timestamp for current model.

protected $with = []; // relations to eager load on every query.

protected $withCount = []; // The relationship counts that should be eager loaded on every query.
}


Override updated_at when saving

We can override the default updated_at behavior by telling the system to ignore the automatic timestamp feature and manually set the field to your desired value.

Here, we’re overriding the default updated_at with our pre-defined one.


$user = User::find(1);
$user->updated_at = '2023-02-27 14:00:00';
$user->save(['timestamps' => false]);


Simple pagination

In pagination, if you need just “Previous/Next” links instead of all the page numbers (and have fewer DB queries because of that), simply change paginate() to simplePaginate().

Here’s an example of the same:


// Instead of
$products = Product::paginate(10);

// Now you can do this
$products = Product::simplePaginate(10);


Laravel eloquent method

isDirty()

isClean()

wasChanged()

The “isDirty()” method determines if any attributes of a model have been changed when retrieved. We can also pass a single attribute to check if its value has been modified or not. Therefore, “isDirty()” method checks whether a model instance value has been changed. The method returns either false or true, where false means the value has changed, and true means the value has not been modified.


$user = User::create([
'name' => 'Test user',
'age' => '21'
]);

$user->age = '30';

$user->isDirty(); // true
$user->isDirty('age'); // true
$user->isDirty('name'); // false

$user->save();


The “isClean()” method is the inverse of the “isDirty()” method. When the “isClean()” method is called, it returns “true” if none of the attributes of the model instance have been modified, and “false” if any attribute has been changed. For a clearer understanding of how the “isClean()” method works, please refer to the example below.


$user = User::create([
'name' => 'Test user',
'age' => '21'
]);

$user->age = '30';

$user->isClean(); // false
$user->isClean('age'); // false
$user->isClean('name'); // true
$user->save();


The “wasChanged()” method determines if after saving data any attribute value has changed. We pass a single attribute in the “wasChanged()” method. Example of “wasChanged()” method include:


$user = User::create([
'name' => 'Test user',
'age' => '21'
]);

$user->age = '30';
$user->save();

$user->wasChanged(); // true
$user->wasChanged('age'); // true
$user->wasChanged('name'); // false


Avoid using Environment (.env) variables directly

Environmental variables are a value that affects the way running processes behave in a computer. While you may be tempted to use them directly in your code, it’s best if you use the config() helper function to access them. Otherwise, external variables, like server-level or system-level environment variables, can easily override your .env file.


// instead of this use below example
$apiKey = env('API_KEY');

// Add first in config file config/api.php
'key' => env('API_KEY'),

// Use the data
$apiKey = config('api.key');
Use “forelse” loop rather than “foreach”
You can use the “forelse” loop in your application as:
Instead of doing this

@if ($users->count())
@foreach ($users as $user)

This is user {{ $user->id }}

@endforeach
@else

No users found.

@endif
-----------------------------------------------------------------------------
Use this

@forelse ($users as $user)

This is user {{ $user->id }}

@empty

No users found.

@endforelse


How to use View Composer

View Composer is used when multiple views require a certain variable or piece of data. For example, the following method could be written in any service provider’s bootmethod. This method attaches a users variable to every view.


View::composer('*', function ($view) {
$view->with('users', User::all());
});


Maintenance mode options

To put your app into maintenance mode, you can run the following command:


php artisan down


To refresh the maintenance page in set intervals when the site is up, run the following command:


php artisan down --refresh=60


To allow bypassing of maintenance mode using a secret token, you may use the secret option to specify a maintenance mode bypass token. This means that if you navigate to your-app-domain.com/your-secret-here, you will have access to view the rest of the application as normal.


php artisan down --secret="your-secret-here"


To disable maintenance mode, use the up command:


php artisan up


Reuse or clone query

To query multiple times from a filtered query, we can use the query() method to reuse or clone the query. For example, let's write a query to retrieve all products that were created today, regardless of their status (active or inactive).


$query = Product::query();


$today = request()->q_date ?? today();
if($today){
$query->where('created_at', $today);
}

// lets get active and inactive products
$activeProducts = $query->where('status', 1)->get();
// this line modified the $query object variable
$inactiveProducts = $query->where('status', 0)->get();
// so here we will not find any inactive products


When we query a database for products, we often need to filter the results based on certain criteria. To achieve this, we create a $query object with the required conditions and then execute it to obtain a collection of products.

However, in some cases, we may need to query the database multiple times with different filter criteria. For example, we may need to retrieve all products created today, regardless of their status (active or inactive).

To accomplish this, we can use the $query object and modify it with the required conditions before executing it. However, this approach can cause issues when we need to retrieve products with different statuses using the same $query object.

For instance, when we obtain the $activeProducts collection, the $query object is modified to retrieve only active products. As a result, $inactiveProducts cannot find any inactive products from the $query object and returns an empty collection every time.

To solve this issue, we can reuse the same $query object by cloning it before modifying it for each query. By doing so, we can retrieve both active and inactive products without affecting the original $query object.


$activeProducts = $query->clone()->where('status', 1)->get();
// it will not modify the $query
$inactiveProducts = $query->clone()->where('status', 0)->get();
// so we will get inactive products from $query
Eloquent where date methods
In Eloquent, check the date with functions whereDay(), whereMonth(), whereYear(), whereDate() and whereTime().
$products = Product::whereDate('created_at', '2023-01-31')->get();
$products = Product::whereMonth('created_at', '12')->get();
$products = Product::whereDay('created_at', '31')->get();
$products = Product::whereYear('created_at', date('Y'))->get();
$products = Product::whereTime('created_at', '=', '14:13:58')->get();


Model all columns

When calling Eloquent’s Model::all(), you can specify which columns to return.


$users = User::all(['id', 'name', 'email']);


DB transactions

When performing two database operations, if the second operation encounters an error, the first operation should be rolled back. To achieve this, we use database transactions. Transactions ensure that the first operation is automatically rolled back if the second operation fails.


DB::transaction(function () {
DB::table('users')->update(['votes' => 1]);

DB::table('posts')->delete();
});


Eager Loading with exact columns

You can use Laravel Eager Loading to retrieve related data along with the main query and specify the exact columns you want to get from the relationship. To optimize performance, you can specify the exact columns you want to retrieve from the related data, rather than retrieving all columns.


$users = Book::with('author:id,name')->get();
You can do that even in deeper, second-level relationships:
$users = Book::with('author.country:id,name')->get();


A shorter way to write whereHas

Released in Laravel 8.57, here’s a shorter way to write whereHas() with a simple condition inside.


// Before
User::whereHas('posts', function ($query) {
$query->where('published_at', '>', now());
})->get();

// After
User::whereRelation('posts', 'published_at', '>', now())->get();

Related Posts