En savoir plus sur les génériques en PHP avec des exemples

Cet article vous donnera une compréhension approfondie des génériques en PHP et présentera deux exemples génériques. J'espère qu'il vous sera utile !

Au fond des génériques

J'ai montré un exemple très ennuyeux de génériques dans mon post précédent et nous ferons mieux dans celui-ci.

$users = new Collection<User>();

$slugs = new Collection<string>();

Collections C'est probablement le moyen le plus simple d'expliquer les génériques, mais ce sont aussi les exemples dont tout le monde parle lorsqu'on parle de génériques. Les gens considèrent souvent les « génériques » et les « collections typées » comme la même chose. Ce n’est absolument pas le cas. 集合 它们可能是解释泛型的最简单方法，但它们也是每个人在讨论泛型时都会谈论的示例。人们通常认为「泛型」和「具有类型的集合」是一回事。绝对不是这样。

所以让我们再看两个例子。

这是一个名为「app」的函数——如果你使用像 Laravel 这样的框架，它可能看起来很熟悉：这个函数接受一个类名，并使用依赖容器解析该类的一个实例：

function app(string $className): mixed
{
    return Container::get($className);
}

现在，你不需要知道容器是如何工作的，重要的是这个函数会给你一个你请求的类的实例。

所以，基本上，它是一个通用函数；一个返回类型取决于你给它的类名。如果我们的 IDE 和其他静态分析器也明白，如果我给这个函数提供类名「UserRepository」，我希望返回一个 UserRepository 的实例，而不是别的，那就太酷了：

function app(string $className): mixed
{ /* … */ }

app(UserRepository::class); // ?

好吧，泛型允许我们这样做。

我想现在是提一下我一直保守秘密的好时机，就像: 我在 上一篇 中提到 PHP 中不存在泛型；好吧，这并不完全正确。那里的所有静态分析器——无需运行即可读取代码的工具，像你的 IDE 之类的工具——他们允许将 doc 块注释用于泛型：

/**
 * @template Type
 * @param class-string<Type> $className
 * @return Type
 */
function app(string $className): mixed
{ /* … */ }

诚然：这不是最完美的语法，所有静态分析器都依赖于一个简单的协议，即这是没有官方规范语法； 但是：它有效。PHP 世界中最大的三个静态分析器：PhpStorm、Psalm 和 PhpStan，都在一定程度上理解这种语法。

像 PhpStorm 这样的 IDE 使用它，以便在程序员编写代码时向他们提供反馈，而像 Psalm 和 PhpStan 这样的工具使用它，来批量分析你的代码库并检测潜在的 bug，主要基于类型定义。

所以实际上，我们可以构建这个 app 函数，使我们的工具不再在黑暗中运行。 当然，PHP 本身并不能保证返回类型是正确的，因为 PHP 不会在运行时对该函数进行类型检查； 但是，如果我们可以相信我们的静态分析器是正确的，那么在运行它时，这段代码就很少——甚至没有机会被中断。

这就是静态分析令人难以置信的力量：实际上,我们可以确定，无需运行我们的代码； 其中大部分将按预期工作。 所有这一切都归功于类型——包括泛型。

让我们来看一个更复杂的例子：

Attributes::in(MyController::class)
    ->filter(RouteAttribute::class)
    ->newInstance()
    ->

在这里，我们有一个可以“查询”属性并即时实例化它们的类。 如果你在知道它们的反射 API 相当冗长之前使用过属性，那么我发现这种辅助类非常有用。

当我们使用 filter 方法时，我们给它一个属性的类名； 然后调用 newInstance

Regardons donc deux autres exemples.

Ceci est une fonction appelée "app" - si vous utilisez un framework comme Laravel, cela peut vous sembler familier : cette fonction prend un nom de classe et résout une instance de cette classe à l'aide du conteneur de dépendances :

/** @template AttributeType */
class Attributes
{
    /**
     * @template InputType
     * @param class-string<InputType> $className
     * @return self<InputType>
     */
    public function filter(string $className): self
    { /* … */ }

    /**
     * @return AttributeType 
     */   
    public function newInstance(): mixed
    { /* … */ }

    // …
}

Maintenant, vous n'avez plus besoin de Sachez comment fonctionne le conteneur, l'important est que cette fonction vous donnera une instance de la classe que vous avez demandée.

Donc, fondamentalement, c'est une fonction générique ; un type de retour qui dépend du nom de classe que vous lui donnez. Ce serait cool si nos IDE et autres analyseurs statiques comprenaient aussi que si je donnais à cette fonction le nom de classe "UserRepository", je voulais renvoyer une instance de UserRepository et rien d'autre :

rrreee

Okay, Kata générique nous permet de faire ça . 🎜🎜 J'ai pensé que ce serait le bon moment pour mentionner un secret que je garde, comme : j'ai mentionné dans mon article précédent que les génériques n'existent pas en PHP et bien, ce n'est pas tout à fait vrai ; Tous les analyseurs statiques disponibles - des outils qui lisent le code sans l'exécuter, des outils comme votre IDE - permettent d'utiliser les commentaires de blocs de doc pour les génériques : 🎜rrreee🎜 Certes : ce n'est pas la syntaxe la plus parfaite, tous les analyseurs statiques s'appuient sur un protocole simple , c'est-à-dire qu'il n'y a pas de syntaxe canonique officielle : cela fonctionne ; Trois des plus grands analyseurs statiques du monde PHP : PhpStorm, Psalm et PhpStan comprennent tous cette syntaxe dans une certaine mesure. 🎜🎜Les IDE comme PhpStorm l'utilisent pour fournir des commentaires aux programmeurs lorsqu'ils écrivent du code, tandis que des outils comme Psalm et PhpStan l'utilisent pour analyser en masse votre base de code et détecter les bogues potentiels, principalement en fonction des définitions de type. 🎜🎜Donc en fait, nous pouvons construire cette fonction app pour que notre outil ne fonctionne plus dans le noir. Bien sûr, PHP lui-même ne peut pas garantir que le type de retour est correct, car PHP ne vérifiera pas la fonction au moment de l'exécution. Cependant, si nous pouvons être sûrs que notre analyseur statique est correct, alors lors de son exécution, ce paragraphe contient très peu de code ; - aucune chance d'interruption. 🎜🎜C'est l'incroyable puissance de l'analyse statique : nous pouvons réellement être sûrs, sans exécuter notre code, que la majeure partie fonctionnera comme prévu ; Tout cela est possible grâce aux types - y compris les génériques. 🎜🎜Regardons un exemple plus complexe : 🎜rrreee🎜Ici, nous avons une classe qui peut « interroger » des propriétés et les instancier à la volée. Je trouve cette classe d'assistance très utile si vous avez utilisé des propriétés avant de savoir que leur API de réflexion est assez verbeuse. 🎜🎜Lorsque nous utilisons la méthode filter, nous lui donnons le nom de classe d'une propriété ; puis nous appelons la méthode newInstance, sachant que le résultat sera une instance de notre classe de filtre. Encore une fois : ce serait formidable si notre IDE comprenait de quoi nous parlons. 🎜🎜Vous l'avez deviné : les génériques nous permettent de faire cela : 🎜rrreee🎜 J'espère que vous commencez à voir le pouvoir des informations de type simple. Il y a quelques années, j'avais besoin d'un plugin IDE pour faire fonctionner ces informations, il me suffit maintenant d'ajouter quelques informations de type. 🎜🎜Cependant, ce dernier exemple ne repose pas uniquement sur les génériques, il y a un autre rôle tout aussi important en jeu. Inférence de type : capacité d'un analyseur statique à "deviner" - ou à déterminer de manière fiable - des types sans que l'utilisateur ne les spécifie. C'est ce qui se passe avec l'annotation de type chaîne. Notre IDE est capable de reconnaître l'entrée que nous fournissons à cette fonction en tant que nom de classe et de déduire le type en tant que type générique. 🎜🎜Donc, tout est réglé, n’est-ce pas : il existe des génériques en PHP et tous les principaux analyseurs statiques savent comment les utiliser. Eh bien... il y a quelques mises en garde. 🎜🎜Tout d'abord, il n'y a pas de spécification officielle sur ce à quoi devraient ressembler les génériques, désormais chaque analyseur statique peut utiliser sa propre syntaxe actuellement, ils se sont mis d'accord sur l'une ou l'autre mais l'avenir n'est guère garanti ; 🎜

Deuxièmement : les blocs de documents ne sont pas optimaux à mon avis. Ils semblent moins importants dans notre base de code. Bien sûr, les annotations génériques ne fournissent qu’un aperçu statique et aucune fonctionnalité d’exécution, mais nous avons constaté la puissance de l’analyse statique même sans vérification du type d’exécution. Je pense qu'il est injuste de considérer les informations de type comme des "commentaires de documentation", cela ne reflète pas l'importance de ces types dans notre code. C'est pourquoi nous avons obtenu des attributs en PHP8 : toutes les fonctionnalités fournies par les attributs étaient possibles dans les commentaires docblock, mais cela ne semblait tout simplement pas assez agréable. Il en va de même pour les génériques.

Remarque finale : sans spécification appropriée, les trois principaux analyseurs statiques présentent des différences entre leurs implémentations génériques. PhpStorm est celui qui manque le plus pour le moment. Idéalement, il y aurait une spécification officielle provenant de PHP. Mais il n’y en a pas encore officiellement.

Ce sont les principales raisons pour lesquelles je pense qu’il vaut la peine d’investir du temps dans des solutions plus durables et plus durables. Alors pourquoi PHP n'a-t-il pas encore de génériques appropriés ? Pourquoi nous appuyons-nous sur des morceaux de documentation sans spécifications claires ?

Adresse d'origine : https://stitcher.io/blog/generics-in-php-2

Adresse de traduction : https://learnku.com/php/t/66484

Recommandé : "Vidéo PHP Tutoriel》

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!