Meilleures pratiques, trucs et astuces Laravel pour 5

À l'approche de 2025, Laravel continue d'être un premier choix pour le développement Web, offrant aux développeurs les outils nécessaires pour créer des applications puissantes et efficaces. Cet article présente les meilleures pratiques, conseils et astuces clés qui peuvent améliorer la qualité de votre code et rationaliser votre flux de travail, que vous utilisiez Laravel 9, 10 ou 11. Ces informations vous aideront à tirer le meilleur parti de Laravel et à améliorer vos compétences en développement. , que vous soyez un développeur débutant ou expérimenté.

Gardez Laravel et les packages à jour

Garder Laravel à jour présente plusieurs avantages clés :

• Sécurité améliorée : les versions régulières incluent des correctifs de sécurité importants qui protègent votre application.
• Meilleures performances : les mises à jour améliorent souvent les performances, ce qui entraîne des temps de chargement plus rapides et un code plus efficace.
• Nouvelles fonctionnalités et fonctionnalités : restez à jour pour profiter des nouvelles fonctionnalités qui améliorent l'expérience de développement.
• Compatibilité : Assurer une meilleure compatibilité avec les derniers packages officiels et communautaires.

L'exécution régulière de composer update est cruciale pour maintenir vos packages à jour. Cette pratique simple est l’un des meilleurs moyens de garantir que vos packages sont à jour avec les dernières fonctionnalités et correctifs de sécurité.

Si vous hésitez sur les mises à jour, cela peut indiquer que votre code n'est pas suffisamment testé. En adoptant des pratiques de test, vous pouvez vous assurer que les mises à jour majeures ne cassent pas votre code, vous permettant ainsi de tirer pleinement parti des améliorations de Laravel.

Si vous préférez ne pas mettre à jour manuellement, pensez à utiliser ServBay, un outil de gestion d'environnement qui a déjà intégré les versions bêta de PHP 8.4, ce qui facilite la mise à jour de Laravel et de divers packages.

Prévenez les erreurs critiques en maintenant des tests rigoureux

Les tests automatisés sont un domaine vaste mais souvent sous-estimé. Cependant, il s'agit de l'une des meilleures pratiques les plus importantes pour garantir la fiabilité du projet.

Les principaux avantages du maintien d'une suite de tests robuste sont les suivants :

• Moins de bugs : des tests réguliers permettent de détecter les problèmes plus tôt, conduisant à une base de code plus stable.
• Clients plus satisfaits : un logiciel fiable se traduit par des utilisateurs satisfaits qui peuvent faire confiance à votre produit.
• Employeurs satisfaits : les projets bien testés reflètent le professionnalisme et un engagement envers la qualité.
• Développeurs confiants : avec une suite de tests complète, vous pouvez apporter des modifications sans vous soucier de l'introduction de nouvelles erreurs. Revenir à un projet après une pause devient moins intimidant.

Lors de la modification du code, exécutez simplement php artisan test pour identifier toute fonctionnalité cassée, résolvez les problèmes et répétez le processus !

Les tests automatisés peuvent améliorer considérablement la stabilité du projet, stimulant ainsi considérablement votre carrière.

Pour vous aider à démarrer, Laracasts propose des cours de test gratuits. Vous pouvez en apprendre davantage sur PHPUnit (le standard de l'industrie) et Pest (un framework de test moderne qui simplifie les tests PHP). Le cours "Pest From Scratch" est fortement recommandé.

Suivre l'organisation de l'annuaire par défaut

Avez-vous déjà réfléchi aux raisons pour lesquelles vous devriez utiliser un framework comme Laravel ?

Les frameworks offrent une approche structurée du développement, garantissant que tous les membres de l'équipe restent cohérents et travaillent vers un objectif commun. Ils sont dotés de fonctionnalités riches, complexes et éprouvées, vous permettant de vous concentrer sur les aspects uniques de votre projet sans vous enliser dans les détails.

Alors, suivre la structure de projet par défaut de Laravel est-il considéré comme une bonne pratique ? Absolument! Voici pourquoi :

• Commodité : les conventions et la structure de Laravel sont bien documentées. Lorsque vous reviendrez sur un projet des semaines ou des mois plus tard, vous apprécierez la clarté et la familiarité de la configuration par défaut.
• Collaboration en équipe : lorsque vous travaillez avec les membres de l'équipe, tout le monde comprend les conventions de Laravel, ce qui facilite la collaboration. Tirer parti de ces connaissances partagées peut faire avancer le projet, plutôt que de réinventer la roue à chaque instant.

Utiliser des demandes de formulaire personnalisé pour une validation complexe

Les demandes de formulaires personnalisés dans Laravel sont des outils puissants pour gérer la validation, offrant plusieurs avantages clés :

• Réutilisez la logique de validation : réutilisez facilement les règles de validation sur plusieurs contrôleurs, en gardant votre code SEC (ne vous répétez pas).
• Réduire le gonflement des contrôleurs : déchargez le code de validation vers des classes de demande de formulaire dédiées, gardant les contrôleurs propres et concentrés sur la logique métier.

Création d'une demande de formulaire personnalisé

Créer une demande de formulaire personnalisé est simple. Exécutez simplement la commande Artisan suivante :

php artisan make:request StorePostRequest

Ensuite, dans votre contrôleur, vous pouvez simplement taper un indice sur la requête :

use App\Http\Requests\StorePostRequest;

class PostController
{
    public function store(StorePostRequest $request)
    {
        $validated = $request->validated();
        Post::create($validated);
        // Other logic...
    }
}

Amélioration des demandes de formulaire personnalisé

Les demandes de formulaire personnalisé peuvent également inclure une logique supplémentaire au-delà de la validation. Par exemple, vous pouvez normaliser les données d'entrée avant qu'elles n'atteignent le contrôleur en remplaçant la méthode prepareForValidation :

public function prepareForValidation()
{
    $this->merge([
        'slug' => Str::slug($this->title),
    ]);
}

Dans cet exemple, la méthode génère automatiquement un slug à partir du titre avant le processus de validation.

Gestion des autorisations

Les demandes de formulaire personnalisé peuvent également gérer la logique d'autorisation. Si vous trouvez l'utilisation de politiques fastidieuses, vous pouvez inclure de simples vérifications d'autorisation directement dans le formulaire de demande.

Simplifiez votre base de code avec des contrôleurs à action unique

Même en suivant les meilleures pratiques, les contrôleurs peuvent devenir lourds. Une excellente solution consiste à utiliser des contrôleurs à action unique dans Laravel. Ces contrôleurs sont conçus pour gérer une seule action, plutôt que plusieurs actions comme les contrôleurs de ressources standard.

Création d'un contrôleur à action unique

Pour créer un contrôleur à action unique, utilisez la commande Artisan suivante :

php artisan make:request StorePostRequest

Cette commande crée un contrôleur avec une seule action, nommée __invoke. Pour plus d'informations sur la méthode magique __invoke, reportez-vous à la documentation Laravel.

Définir des itinéraires

Avec un contrôleur à action unique, vous pouvez simplifier les définitions d'itinéraire. Voici comment l'utiliser dans vos itinéraires :

use App\Http\Requests\StorePostRequest;

class PostController
{
    public function store(StorePostRequest $request)
    {
        $validated = $request->validated();
        Post::create($validated);
        // Other logic...
    }
}

Meilleure pratique subjective

L'utilisation de contrôleurs à action unique est une bonne pratique subjective. C'est à vous et à votre équipe de déterminer si cette approche correspond à la structure et aux préférences de lisibilité du projet.

Utilisez un middleware pour éviter la duplication de code

Dans Laravel, le middleware est un outil puissant qui permet de filtrer ou de modifier les requêtes entrantes. En tirant parti du middleware, vous pouvez éviter la duplication de code et garder les contrôleurs propres et gérables. Voici quelques cas d'utilisation courants du middleware :

• Vérifiez les autorisations requises : assurez-vous que les utilisateurs disposent des autorisations nécessaires pour accéder à certains itinéraires.
• Définir les paramètres régionaux de l'utilisateur : vérifiez la langue préférée de l'utilisateur et ajustez les paramètres régionaux de l'application en conséquence.

Laravel fournit divers middleware intégrés pour les tâches courantes, telles que l'authentification et la limitation de débit.

Création d'un middleware personnalisé

Pour créer un middleware personnalisé, utilisez la commande Artisan suivante :

public function prepareForValidation()
{
    $this->merge([
        'slug' => Str::slug($this->title),
    ]);
}

Dans votre middleware, vous pouvez définir la logique pour gérer la requête. Voici un exemple de middleware qui vérifie si un utilisateur dispose de suffisamment de jetons :

php artisan make:controller ShowPostController --invokable

Attacher un middleware aux routes

Une fois que vous avez défini votre middleware, vous pouvez l'attacher à n'importe quel nombre de routes. Cette approche modulaire permet de garder votre code propre et réduit la duplication dans les contrôleurs.

use App\Http\Controllers\ShowPostController;

// Single action controller route
Route::get('/posts/{post}', ShowPostController::class);

Utiliser des stratégies pour l'autorisation

L'utilisation de politiques d'autorisation dans Laravel est cruciale pour créer des applications claires et maintenables. Les trois principaux avantages de l'utilisation de politiques sont les suivants :

• Logique d'autorisation partagée entre les contrôleurs : en consolidant les règles d'autorisation dans des politiques, vous favorisez la cohérence et éliminez le code en double dans votre application.
• Complexité des contrôleurs réduite : le déplacement de la logique d'autorisation vers les stratégies permet aux contrôleurs de se concentrer sur leurs tâches principales, ce qui entraîne un code plus propre et plus compréhensible.
• Accès simplifié au code d'autorisation : les politiques sont situées dans le répertoire app/Policies, ce qui permet aux développeurs de trouver et de modifier facilement les règles d'autorisation en cas de besoin.

Examinons un scénario pratique d'utilisation d'une politique pour les mises à jour des publications :

php artisan make:request StorePostRequest

Assurez-vous que les migrations sont à jour

Les migrations sont un moyen de définir le schéma de la base de données en utilisant du code PHP pur. Vous pouvez les considérer comme une alternative de code à phpMyAdmin, fournissant un moyen programmatique de gérer la structure de votre base de données. Cette approche est particulièrement bénéfique pour les équipes, car elle permet à chacun de répliquer le même environnement de développement sur ses machines locales et de conserver un historique clair des modifications dans Git.

Les migrations facilitent également le déploiement de projets vers de nouveaux environnements (comme la préparation ou la production) sans avoir besoin d'exporter la base de données depuis d'autres environnements. Cependant, un piège courant est que certains développeurs apportent des modifications directement à la base de données au lieu de créer de nouvelles migrations. Cette pratique peut gêner les autres membres de l'équipe, qui pourraient avoir besoin de demander un vidage de la base de données via Slack. Pour élever le projet et maintenir la cohérence, il est important d'utiliser efficacement les migrations.

Utilisez des migrations anonymes pour éviter les conflits (Laravel 8 et supérieur)

Les migrations anonymes sont une solution efficace pour éviter les conflits de noms de classes. Avec cette fonctionnalité, vous pouvez créer plusieurs migrations nommées "update_posts_table" sans rencontrer d'erreurs, réduisant ainsi les frictions pendant le processus de développement.

Dans Laravel 9 et supérieur, lorsque vous exécutez la commande suivante, des migrations anonymes sont générées automatiquement :

use App\Http\Requests\StorePostRequest;

class PostController
{
    public function store(StorePostRequest $request)
    {
        $validated = $request->validated();
        Post::create($validated);
        // Other logic...
    }
}

La structure de ces migrations ressemble à ceci :

public function prepareForValidation()
{
    $this->merge([
        'slug' => Str::slug($this->title),
    ]);
}

Fait intéressant, vous pouvez également implémenter des migrations anonymes dans Laravel 8. Pour ce faire, remplacez simplement le nom de la classe par return new class et assurez-vous d'inclure un point-virgule à la fin. De cette façon, vous pouvez profiter des avantages des migrations anonymes même dans les versions antérieures.

Implémentez correctement la méthode down() pour les restaurations

La méthode down() est utilisée par la commande php artisan migrate:rollback pour annuler les modifications apportées à la base de données. Lorsque certains développeurs choisissent de l’implémenter alors que d’autres ne le font pas, il est important de s’assurer que si vous l’utilisez, votre méthode down() est définie correctement.

Essentiellement, la méthode down() doit inverser les opérations effectuées dans la méthode up(). Voici un exemple simple :

php artisan make:request StorePostRequest

Si vous préférez ne pas utiliser la méthode down(), vous pouvez simplement la supprimer.

Suivez les conventions de dénomination des tables de base de données d'Eloquent

Adhérer aux conventions de dénomination des tables de Laravel est une bonne pratique simple qui peut grandement profiter à votre équipe. Lorsque vous utilisez les commandes Artisan, le framework gère automatiquement ces conventions, telles que php artisan make:model Post --migration --factory.

Si, pour une raison quelconque, vous ne pouvez pas utiliser ces commandes, voici un guide rapide :

• Pour un modèle nommé Post, la table correspondante doit être nommée posts, au pluriel. Par exemple :

  • Modèle de commentaire → tableau des commentaires
  • Modèle de réponse → tableau des réponses

• Pour un tableau croisé dynamique reliant Post et Comment (par exemple, comment_post) :

  • Utilisez la forme singulière des deux noms.
  • Organisez-les par ordre alphabétique.

Pour plus de détails, reportez-vous à la documentation officielle.

Évitez le problème N 1 en utilisant le chargement rapide

Il y a d’autres bonnes pratiques à aborder ! Avez-vous rencontré le problème N1 ? Le chargement impatient est un moyen efficace de les prévenir.

Par exemple, si vous affichez une liste de 30 articles et leurs auteurs, en raison d'un chargement paresseux, Eloquent exécutera une requête pour les 30 articles puis 30 requêtes supplémentaires pour chaque auteur (ce qui signifie à chaque fois que vous appelez $post -> user dans votre code, il récupère la relation utilisateur).

La solution est simple : utilisez la méthode with() pour réduire le nombre de requêtes de 31 à 2.

use App\Http\Requests\StorePostRequest;

class PostController
{
    public function store(StorePostRequest $request)
    {
        $validated = $request->validated();
        Post::create($validated);
        // Other logic...
    }
}

Pour éviter les problèmes N 1, vous pouvez configurer l'application pour qu'elle lève une exception chaque fois qu'une relation est chargée paresseusement. Cette restriction ne doit être appliquée que dans les environnements locaux.

public function prepareForValidation()
{
    $this->merge([
        'slug' => Str::slug($this->title),
    ]);
}

Utilisez le mode strict d'Eloquent pour éviter les problèmes de performances et les erreurs

Le mode strict d'Eloquent est un outil de débogage précieux. Il aide les développeurs à identifier les problèmes potentiels pendant le développement en lançant des exceptions dans divers scénarios :

• Relations à chargement paresseux : le chargement paresseux peut entraîner des problèmes de performances, en particulier lorsqu'il s'agit de grands ensembles de données. Cette situation se produit lorsque les modèles associés sont extraits de la base de données uniquement lors de l'accès. En mode strict, une exception sera levée si une relation est chargée paresseusement, encourageant l'utilisation du chargement hâtif.
• Attribution d'attributs non remplissables : la propriété $fillable dans les modèles Eloquent empêche les vulnérabilités d'affectation en masse. Si vous tentez d'attribuer des attributs non remplissables, une exception sera déclenchée, garantissant que les développeurs restent prudents lors de la gestion de l'attribution en masse.
• Accès à des attributs inexistants : tenter d'accéder à des attributs qui n'existent pas ou qui n'ont pas été récupérés de la base de données peut entraîner un comportement imprévisible ou des erreurs. Le mode strict générera des exceptions dans de tels cas, aidant ainsi les développeurs à localiser et à résoudre ces problèmes.

Pour activer le mode strict, ajoutez le code suivant à la méthode boot() de AppServiceProvider.php :

php artisan make:request StorePostRequest

Utilisez la nouvelle méthode pour définir les accesseurs et les mutateurs

Laravel 9 a introduit une nouvelle façon de déclarer les accesseurs et les mutateurs. Voici comment les mettre en œuvre dès maintenant :

use App\Http\Requests\StorePostRequest;

class PostController
{
    public function store(StorePostRequest $request)
    {
        $validated = $request->validated();
        Post::create($validated);
        // Other logic...
    }
}

Cette nouvelle syntaxe vous permet de définir les accesseurs et les mutateurs de manière plus concise. Vous pouvez également mettre en cache des valeurs coûteuses en termes de calcul :

public function prepareForValidation()
{
    $this->merge([
        'slug' => Str::slug($this->title),
    ]);
}

En revanche, la méthode précédente ressemblait à ceci :

php artisan make:controller ShowPostController --invokable

Le passage à la nouvelle syntaxe simplifie le code et améliore la lisibilité.

Utilisez dispatchAfterResponse() pour gérer les tâches de longue durée

Lorsque vous traitez des tâches chronophages (comme l'envoi d'e-mails après avoir soumis un formulaire de contact), vous pouvez améliorer l'expérience utilisateur en retardant la tâche jusqu'à ce que le serveur réponde à l'utilisateur. C'est là que dispatchAfterResponse() entre en jeu, vous permettant de reporter les processus de longue durée :

use App\Http\Controllers\ShowPostController;

// Single action controller route
Route::get('/posts/{post}', ShowPostController::class);

Alternativement, si vous préférez planifier des tâches à l'aide d'une fonction anonyme, vous pouvez le faire comme ceci :

php artisan make:middleware CheckTokens

En utilisant dispatchAfterResponse(), vous vous assurez que les utilisateurs reçoivent une réponse plus rapide du serveur tandis que les tâches en arrière-plan n'affectent pas l'expérience utilisateur.

Utiliser des files d'attente pour gérer les tâches de longue durée

Lors du traitement de tâches gourmandes en calcul (comme la gestion des images téléchargées par les utilisateurs), l'exécution immédiate de ces opérations peut surcharger le serveur et conduire à une mauvaise expérience utilisateur. Voici comment y remédier :

• Pression du serveur : La soumission de tâches de traitement en temps réel pour chaque utilisateur peut surcharger le serveur.
• Expérience utilisateur : les utilisateurs sont obligés d'attendre, regardant un écran de chargement, ce qui entraîne de la frustration.

Le système de file d'attente de Laravel vous permet de différer ces tâches de longue durée pour qu'elles s'exécutent de manière parallèle ordonnée ou contrôlée, garantissant ainsi que le serveur reste réactif et que les utilisateurs n'ont pas à attendre.

Pour faciliter la gestion des tâches, pensez à utiliser Laravel Horizon, qui fournit une interface utilisateur pour surveiller et contrôler efficacement les tâches en file d'attente. De cette façon, vous pouvez gérer des processus complexes en arrière-plan tout en conservant des performances fluides.

Actualiser paresseusement la base de données avant chaque test

Lors des tests dans un environnement local, il est préférable d'utiliser une nouvelle base de données à chaque fois que vous exécutez des tests. Laravel fournit un moyen efficace de gérer cela en actualisant paresseusement la base de données avant chaque test. Cela peut être accompli en utilisant le trait RefreshDatabase dans votre classe de test. Cela garantit que la base de données est dans un état propre à chaque fois que des tests sont exécutés, éliminant ainsi les problèmes potentiels causés par les données restantes.

Utilisation de RefreshDatabase

Utilisez le trait RefreshDatabase dans votre classe de test :

php artisan make:request StorePostRequest

Avantages

• Cohérence : garantit que l'état de la base de données est cohérent à chaque fois que des tests sont exécutés, évitant ainsi les échecs de test dus à des changements d'état.
• Isolement : Chaque test s'exécute indépendamment, sans interférence, améliorant ainsi la fiabilité des tests.

Gérer en toute sécurité les informations sensibles

Lors de la gestion d’informations sensibles, assurer la sécurité est crucial. Voici quelques bonnes pratiques :

Utiliser des variables d'environnement

Stockez les informations sensibles (telles que les clés API et les informations d'identification de la base de données) dans le fichier .env plutôt que dans la base de code.

Utilisez les fonctionnalités de cryptage de Laravel

Pour les données nécessitant un cryptage, utilisez les fonctionnalités de cryptage de Laravel :

use App\Http\Requests\StorePostRequest;

class PostController
{
    public function store(StorePostRequest $request)
    {
        $validated = $request->validated();
        Post::create($validated);
        // Other logic...
    }
}

Mettre régulièrement à jour les clés

Assurez-vous de mettre régulièrement à jour les clés d'application (APP_KEY) et de recrypter les données après les mises à jour.

Conclusion

En suivant ces bonnes pratiques, conseils et astuces, vous pouvez améliorer considérablement la qualité et la sécurité de vos applications Laravel. Ces méthodes vous aideront non seulement à écrire du code plus efficace, mais offriront également une meilleure expérience à vos utilisateurs. Continuer à apprendre et à appliquer ces pratiques vous aidera à réussir davantage dans votre développement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!