Top 5 des fonctionnalités Laravel à connaître

Je parle régulièrement de Laravel sur ce blog car c’est un framework PHP que j’affectionne particulièrement. Je l’utilise quotidiennement dans mon travail depuis des années et je suis constamment à l’affût de fonctionnalités pour me faciliter la vie.

Ce top 5 des fonctionnalités Laravel est tiré de mon expérience, et il est possible que le votre soit très différent. Il n’y a pas d’ordre, ce sont juste 5 fonctionnalités que j’apprécie particulièrement et que j’ai utilisé récemment. Je vous invite à partager vos fonctionnalités préférées dans les commentaires !

1 – Partager une variable à toutes les vues

J’ai récemment publié cet article à ce sujet. C’est une fonctionnalité Laravel que j’ai découvert récemment mais qui m’a bien facilité la vie dans un projet utilisant massivement les vues Blade.

<?php
 
namespace App\Providers;
 
use Illuminate\Support\Facades\View;
 
class AppServiceProvider extends ServiceProvider
{
    /**
     * Register any application services.
     *
     * @return void
     */
    public function register()
    {
        //
    }
 
    /**
     * Bootstrap any application services.
     *
     * @return void
     */
    public function boot()
    {
        View::share('key', 'value');
    }
}

Avec la méthode View::share() vous pouvez rendre accessible une variable à toutes les vues du projet très simplement.

2 – Optimiser les requêtes Eloquent avec toBase()

Eloquent est l’ORM (Object Relationnal Mapper) de Laravel. Il est extrêmement souple et puissant pour 90% des besoins courants d’une application web. Il permet de générer des requêtes complexes sur plusieurs niveaux de jointures en quelques lignes.

Cependant, quand on a beaucoup de données à gérer, utiliser le Builder d’Eloquent pour exécuter une requête peut s’avérer très lent. Ce qui se passe, c’est qu’Eloquent va exécuter la requête, puis pour chaque ligne de résultat, il va instancier un model pour retourner une collection de modèles eloquents.

Si instancier quelques dizaines ou centaines de modèles est relativement rapide, en instancier des milliers ou des centaines de milliers va vite poser des problèmes de performances. Pour cela, Laravel nous met à disposition une méthode presque magique quand on la découvre pour la première fois. La méthode $query->toBase():

<?php
// Initialisation de la requête
$query = Commande::join(...)
            ->join(...)
            ->addSelect([...])
            ->where(...)
            ->groupBy('column')
            ->orderBy('column');

// Exécution de la requête "Eloquent"
$query->get();

// Exécution de la requête "Basique"
$query->toBase()->get();

3 – Caster automatiquement les attributs Eloquent

On reste sur l’ORM Eloquent, mais cette fois pour transformer automatiquement les attributs d’un modèle. Il peut être pratique dans certains cas de transformer automatiquement un attribut vers un type PHP ou une classe. Quelques exemples parlants sont:

  • Un booléen
  • Une date
  • Un Objet JSON

Pour cela, les modèles Eloquent disposent d’un attribut protected $casts qui permet de définir quels champs seront transformés à la volée:

<?php
 
namespace App\Models;
 
use Illuminate\Database\Eloquent\Model;
 
class User extends Model
{
    /**
     * The attributes that should be cast.
     *
     * @var array
     */
    protected $casts = [
        'is_admin' => 'boolean',
        'created_at' => 'date'
    ];
}

4 – Lier un model à une route

Souvent, quand on construit une API, on attend un id en paramètre de la route. Cet id est utilisé pour récupérer et retourner une ressource en base de données.

Laravel simplifie ce processus avec le concept de « Route Model Binding« . Ce concept permet de convertir automatiquement un paramètre de route de type ID en un model Eloquent correspondant.

use App\Http\Controllers\UtilisateurController;
use App\Models\Utilisateur;
 
// Définition de la route...
Route::get('/utilisateurs/{utilisateur}', [UtilisateurController::class, 'show']);
 
// Définition de la méthode du controller...
public function show(Utilisateur $utilisateur)
{
    return view('utilisateur.profile', ['utilisateur' => $utilisateur]);
}

Le principe est de spécifier le type du paramètre dans le controller : public function show(Utilisateur $utilisateur). PHP est un langage réflexif et Laravel exploite toute sa puissance pour aller chercher le bon model en fonction du type donné au paramètre.

5 – Les groupes de middleware

Le concept de middleware est un des piliers de l’architecture de Laravel. Il permet de définir des actions entre l’arrivée de la requête au serveur et son traitement par les contrôleurs. Par exemple, pour démarrer la session, pour valider que l’utilisateur est bien authentifié, pour vérifier le token CSRF etc…

En tant que développeur on peut créer et ajouter nos propres middlewares aux requêtes pour gérer des problématiques de manière globale sur plusieurs routes. Pour ajouter un middleware sur une route, on utilise la syntaxe suivante dans le fichier des routes:

Route::get('/profile', function () {
    //
})->middleware('auth');

Mais on peut aussi avoir besoin d’appliquer plusieurs middlewares à différentes routes ou groupes de routes. Les ajouter uns par uns aux routes peut vite ajouter de la complexité au fichier des routes. Pour cela, Laravel propose une façon de grouper les middlewares entre eux, pour ensuite appliquer tout le groupe à une route.

Ça se passe dans le fichier app/Http/Kernel.php :

/**
 * The application's route middleware groups.
 *
 * @var array
 */
protected $middlewareGroups = [
    'web' => [
        \App\Http\Middleware\EncryptCookies::class,
        \Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse::class,
        \Illuminate\Session\Middleware\StartSession::class,
        // \Illuminate\Session\Middleware\AuthenticateSession::class,
        \Illuminate\View\Middleware\ShareErrorsFromSession::class,
        \App\Http\Middleware\VerifyCsrfToken::class,
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],
 
    'api' => [
        'throttle:api',
        \Illuminate\Routing\Middleware\SubstituteBindings::class,
    ],
];

Par défaut Laravel met à disposition 2 groupes: api et web. Ces groupes sont appliqués de manière globale aux routes des fichiers api.php et web.php

De la même manière, on peut créer nos propres groupes et les appliquer manuellement sur les routes ou les groupes de routes.

Route::middleware(['monGroup'])->group(function () {
    // Les routes exécuteront tous les middlewares du groupe
});

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *