Génériques PHP dans Laravel 11
Si vous êtes un créateur d'applications Web avec Laravel et que vous utilisez PHPStan pour l'analyse de code statique, vous commencerez à voir de nouvelles erreurs lors de la mise à niveau vers Laravel 11.x.
Dans une nouvelle installation de Laravel avec PHPStan, lors de la première exécution de ./vendor/bin/phpstan, l'erreur suivante est générée :
------ ----------------------------------------------------------------------------------- Line app\Models\User.php ------ ----------------------------------------------------------------------------------- 13 Class App\Models\User uses generic trait Illuminate\Database\Eloquent\Factories\HasFactory but does not specify its types: TFactory ------ -----------------------------------------------------------------------------------
Alors, qu’est-ce qui a changé ? Dans Laravel 11, le trait HasFactory possède désormais un PHPDoc avec la balise @template qui est l'une des balises génériques réservées. Comme vous l'avez peut-être déjà deviné, les génériques sont utilisés dans de nombreuses parties du framework.
/** * @template TFactory of \Illuminate\Database\Eloquent\Factories\Factory */ trait HasFactory { ... }
Bien que cela ne soit pas recommandé, cette catégorie d'erreurs peut être ignorée en ajoutant simplement ces lignes de code à votre fichier phpstan.neon :
parameters: ignoreErrors: - identifier: missingType.generics
Mais les génériques ne sont pas si difficiles à comprendre, alors commençons !
Que sont les génériques ?
Les génériques en programmation font référence à une fonctionnalité qui vous permet d'écrire du code pouvant fonctionner avec plusieurs types de données. Au lieu d'écrire du code séparé pour chaque type de données, vous pouvez écrire un seul morceau de code générique qui peut fonctionner sur différents types tout en maintenant la sécurité des types, contrairement à l'utilisation de types généraux comme mixtes ou objets.
Prenez la méthode IlluminateDatabaseConcernsBuildsQueries::first de Laravel 10, elle peut renvoyer une instance de Model, un objet général, une instance de la classe l'utilisant comme IlluminateDatabaseEloquentBuilder ou null.
/** * Execute the query and get the first result. * * @param array|string $columns * @return \Illuminate\Database\Eloquent\Model|object|static|null */ public function first($columns = ['*']) { return $this->take(1)->get($columns)->first(); }
Syntaxe générique
Les génériques ne sont pas pris en charge en PHP en tant que citoyen de première classe, pour les avoir, nous utilisons les balises PHPDocs @template, @template-covariant, @template-contravariant, @extends, @implements et @use.
Les règles des types génériques sont définies à l'aide de paramètres de type. Dans PHPDocs nous les annotons avec la balise @template . Le nom du paramètre de type peut être n’importe quoi, tant que vous n’utilisez pas de nom de classe existant. Vous pouvez également limiter les types pouvant être utilisés à la place du paramètre type avec une limite supérieure à l'aide du mot-clé of. C'est ce qu'on appelle paramètre de type borné.
<?php namespace Illuminate\Database\Eloquent; /** * @template TModel of \Illuminate\Database\Eloquent\Model * */ class Builder implements BuilderContract { }
Types de génériques PHP
Fonction générique
Une fonction générique est exactement comme une fonction normale, cependant, elle a des paramètres de type. Cela permet d'utiliser la méthode générique de manière plus générale.
Prenons la méthode IlluminateSupportValidatedInput::enum comme exemple :
Il définit un paramètre de type TEnum.
Le paramètre $enumClass est du pseudo type classe-chaîne et délimité au même paramètre de type TEnum.
Le type de retour peut également être TEnum ou null.
------ ----------------------------------------------------------------------------------- Line app\Models\User.php ------ ----------------------------------------------------------------------------------- 13 Class App\Models\User uses generic trait Illuminate\Database\Eloquent\Factories\HasFactory but does not specify its types: TFactory ------ -----------------------------------------------------------------------------------
Si vous appelez ensuite $request→validated()→enum('status', OrderStatus::class), PHPStan saura que vous obtenez un objet OrderStatus ou null !
Classe générique
Les classes génériques permettent de créer des classes capables de fonctionner sur n'importe quel type de données tout en garantissant la sécurité des types. Ils permettent de définir une classe avec un espace réservé pour un type spécifique, qui peut ensuite être remplacé lorsque la classe est instanciée.
Un bon exemple du code source de Laravel serait la classe IlluminateDatabaseEloquentBuilder :
/** * @template TFactory of \Illuminate\Database\Eloquent\Factories\Factory */ trait HasFactory { ... }
Un paramètre de type TModel est défini et lié à n'importe quelle sous-classe de IlluminateDatabaseEloquentModel. Le même paramètre de type est utilisé comme type de retour de la méthode make.
Un autre exemple serait si nous avions un modèle de commande, qui a une portée locale pour filtrer les commandes en fonction de leur statut. La méthode scope doit spécifier le type de TModel
parameters: ignoreErrors: - identifier: missingType.generics
ℹ️ info : Toutes les classes de relations Eloquent dans l'espace de noms IlluminateDatabaseEloquentRelations comme BelongsTo et HasOne sont désormais génériques.
Interface générique
Les interfaces génériques ne sont pas si différentes. L'IlluminateContractsSupportArrayable est un exemple d'interface générique
/** * Execute the query and get the first result. * * @param array|string $columns * @return \Illuminate\Database\Eloquent\Model|object|static|null */ public function first($columns = ['*']) { return $this->take(1)->get($columns)->first(); }
L'interface définit deux paramètres de type : TKey de type array-key (il peut s'agir d'un entier ou d'une chaîne) et TValue. Ces deux paramètres permettent de définir le type de retour de la fonction toArray. Voici un exemple :
<?php namespace Illuminate\Database\Eloquent; /** * @template TModel of \Illuminate\Database\Eloquent\Model * */ class Builder implements BuilderContract { }
La classe utilisateur implémente l'interface Arrayable et spécifie le type Tkey sous la forme d'un int et la TValue sous la forme d'une chaîne.
Caractère générique
Nous sommes tombés sur le trait IlluminateDatabaseEloquentFactoriesHasFactory dans l'erreur au début de cet article. Regardons de plus près :
/** * @template TEnum * * @param string $key * @param class-string<TEnum> $enumClass * @return TEnum|null */ public function enum($key, $enumClass) { if ($this->isNotFilled($key) || ! enum_exists($enumClass) || ! method_exists($enumClass, 'tryFrom')) { return null; } return $enumClass::tryFrom($this->input($key)); }
HasFactory définit un paramètre de type TFactory délimité aux sous-classes de IlluminateDatabaseEloquentFactoriesFactory. Alors, comment cette erreur peut-elle être corrigée ?
Le type TFactory doit être spécifié lorsque le trait est utilisé. Ainsi, l'instruction use du trait HasFactory doit être annotée avec le PHPDocs @use:
<?php namespace Illuminate\Database\Eloquent; /** * @template TModel of \Illuminate\Database\Eloquent\Model */ class Builder implements BuilderContract { /** * @param array $attributes * @return TModel */ public function make(array $attributes = []) { return $this->newModelInstance($attributes); } }
Préserver le caractère générique
Lors de l'extension d'une classe, de l'implémentation d'une interface ou de l'utilisation d'un trait, il est possible de conserver le caractère générique de la sous-classe.
La préservation du caractère générique est implémentée en définissant les mêmes paramètres de type au-dessus de la classe enfant et en les transmettant aux balises @extends, @implements et @use.
Nous utiliserons le trait générique IlluminateDatabaseConcernsBuildsQueries comme exemple,
il définit un paramètre de type TValue :
------ ----------------------------------------------------------------------------------- Line app\Models\User.php ------ ----------------------------------------------------------------------------------- 13 Class App\Models\User uses generic trait Illuminate\Database\Eloquent\Factories\HasFactory but does not specify its types: TFactory ------ -----------------------------------------------------------------------------------
La classe IlluminateDatabaseEloquentBuilder utilise ce trait mais conserve son caractère générique en lui passant le type de paramètre TModel. Il appartient désormais au code client de spécifier le type de TModel et par conséquent TValue dans le trait BuildsQueries.
/** * @template TFactory of \Illuminate\Database\Eloquent\Factories\Factory */ trait HasFactory { ... }
Pensées finales
En conclusion, bien que PHP ne prenne pas en charge nativement les génériques de la même manière que certains autres langages de programmation, l'introduction d'astuces et d'outils de type avancés comme PHPStan permet aux développeurs d'implémenter des fonctionnalités de type générique dans leur code. . En tirant parti de PHPDocs, des classes paramétrées et des interfaces, vous pouvez créer des applications plus flexibles et plus sécurisées qui favorisent la réutilisabilité et la maintenabilité du code. À mesure que PHP continue d'évoluer, l'attention croissante de la communauté sur la sécurité des types et l'analyse statique conduira probablement à des solutions plus robustes pour l'implémentation de génériques. L'adoption de ces pratiques améliore non seulement vos compétences en codage, mais contribue également au développement de logiciels de haute qualité qui résistent à l'épreuve du temps.
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!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds











Dans PHP, Password_Hash et Password_verify Les fonctions doivent être utilisées pour implémenter le hachage de mot de passe sécurisé, et MD5 ou SHA1 ne doit pas être utilisé. 1) Password_hash génère un hachage contenant des valeurs de sel pour améliorer la sécurité. 2) Password_verify Vérifiez le mot de passe et assurez-vous la sécurité en comparant les valeurs de hachage. 3) MD5 et SHA1 sont vulnérables et manquent de valeurs de sel, et ne conviennent pas à la sécurité de mot de passe moderne.

PHP et Python ont chacun leurs propres avantages et choisissent en fonction des exigences du projet. 1.Php convient au développement Web, en particulier pour le développement rapide et la maintenance des sites Web. 2. Python convient à la science des données, à l'apprentissage automatique et à l'intelligence artificielle, avec syntaxe concise et adaptée aux débutants.

PHP est largement utilisé dans le commerce électronique, les systèmes de gestion de contenu et le développement d'API. 1) E-commerce: Utilisé pour la fonction de panier et le traitement des paiements. 2) Système de gestion du contenu: utilisé pour la génération de contenu dynamique et la gestion des utilisateurs. 3) Développement des API: Utilisé pour le développement de l'API RESTful et la sécurité de l'API. Grâce à l'optimisation des performances et aux meilleures pratiques, l'efficacité et la maintenabilité des applications PHP sont améliorées.

PHP est un langage de script largement utilisé du côté du serveur, particulièrement adapté au développement Web. 1.Php peut intégrer HTML, traiter les demandes et réponses HTTP et prend en charge une variété de bases de données. 2.PHP est utilisé pour générer du contenu Web dynamique, des données de formulaire de traitement, des bases de données d'accès, etc., avec un support communautaire solide et des ressources open source. 3. PHP est une langue interprétée, et le processus d'exécution comprend l'analyse lexicale, l'analyse grammaticale, la compilation et l'exécution. 4.PHP peut être combiné avec MySQL pour les applications avancées telles que les systèmes d'enregistrement des utilisateurs. 5. Lors du débogage de PHP, vous pouvez utiliser des fonctions telles que error_reportting () et var_dump (). 6. Optimiser le code PHP pour utiliser les mécanismes de mise en cache, optimiser les requêtes de base de données et utiliser des fonctions intégrées. 7

Le type PHP invite à améliorer la qualité et la lisibilité du code. 1) Conseils de type scalaire: Depuis PHP7.0, les types de données de base sont autorisés à être spécifiés dans les paramètres de fonction, tels que INT, Float, etc. 2) Invite de type de retour: Assurez la cohérence du type de valeur de retour de fonction. 3) Invite de type d'union: Depuis PHP8.0, plusieurs types peuvent être spécifiés dans les paramètres de fonction ou les valeurs de retour. 4) Invite de type nullable: permet d'inclure des valeurs nulles et de gérer les fonctions qui peuvent renvoyer les valeurs nulles.

PHP est toujours dynamique et occupe toujours une position importante dans le domaine de la programmation moderne. 1) La simplicité de PHP et le soutien communautaire puissant le rendent largement utilisé dans le développement Web; 2) sa flexibilité et sa stabilité le rendent exceptionnelle dans la gestion des formulaires Web, des opérations de base de données et du traitement de fichiers; 3) PHP évolue et optimise constamment, adapté aux débutants et aux développeurs expérimentés.

PHP et Python ont leurs propres avantages et inconvénients, et le choix dépend des besoins du projet et des préférences personnelles. 1.Php convient au développement rapide et à la maintenance des applications Web à grande échelle. 2. Python domine le domaine de la science des données et de l'apprentissage automatique.

PHP convient au développement Web, en particulier dans le développement rapide et le traitement du contenu dynamique, mais n'est pas bon dans les applications de la science des données et de l'entreprise. Par rapport à Python, PHP présente plus d'avantages dans le développement Web, mais n'est pas aussi bon que Python dans le domaine de la science des données; Par rapport à Java, PHP fonctionne moins bien dans les applications au niveau de l'entreprise, mais est plus flexible dans le développement Web; Par rapport à JavaScript, PHP est plus concis dans le développement back-end, mais n'est pas aussi bon que JavaScript dans le développement frontal.
