Français
Français
Voyons d'abord un exemple typique. Dans un processus d'enregistrement des services, afin de s'assurer que le service est conforme à une certaine interface, les développeurs utiliseront des codes similaires à ce qui suit:
<code> if (! is_a ($ serviceInstance, myServiceInterface :: class)) {lancez new invalidargumentException ("Le service doit implémenter MyServiceInterface"); } </code>En surface, cela empêche l'injection de types d'erreur pendant la phase d'enregistrement, évitant ainsi les erreurs d'exécution. En effet, cette approche est une garantie d'isolement de l'interface. Mais voici la question: est-il vraiment nécessaire de vérifier manuellement?
À partir de PHP 7, l'invite de type est suffisamment puissante:
<code> Fonction Registerservice (MyServiceInterface $ Service) {// ...} </code>À l'heure actuelle, si vous passez dans un cas qui ne correspond pas à MyServiceInterface , PHP lui-même lancera un TypeError . Alors, avons-nous encore besoin de le vérifier manuellement avec IS_A () ?
En fait, ce n'est pas nécessaire. À moins que votre code ne permette de passer des types mixtes ou que la source de l'instance de service soit très incertaine (comme une injection d'instance distante, le chargement du système de plug-in, etc.), le mécanisme de l'invite de type PHP est suffisant.
La surutilisation de IS_A () apportera quelques problèmes cachés:
Vérification répétée : Le système de type a été vérifié et le faire manuellement est répété pour augmenter le fardeau de maintenance.
Polymorphisme d'obstacle : certaines classes d'implémentation peuvent générer des instances en utilisant des méthodes de trait ou de proxy dynamique, et la vérification de IS_A () peut le faire mal juger en tant qu'objet illégal.
Rendre la logique du conteneur redondant : la responsabilité d'un conteneur est d'analyser et d'injecter des dépendances, plutôt que de la vérification de force des types. Une responsabilité trop lourde peut facilement conduire au couplage.
Cela ne signifie pas que is_a () est inutile. Il est toujours utile dans les scénarios suivants:
Système de plugin: lorsque la classe étendue fournie par un tiers ne peut pas être contrainte à l'aide d'invites de type, l'utilisation de l'IS_A () peut échouer à l'avance.
Enregistrement de service dynamique: par exemple, lors de la lecture d'un fichier de configuration pour instancier dynamiquement le service, la vérification IS_A () appropriée est acceptable pour des raisons de sécurité.
Évitez l'injection malveillante: dans les grands systèmes, certains modules peuvent être maintenus par plusieurs équipes et en utilisant IS_A () car la stratégie de défense finale est également une stratégie ascendante.
Dans la logique d'enregistrement de service normal, il est recommandé d'utiliser l'injection de type de type natif + l'injection de dépendance automatique dans la mesure du possible. Gardez le code simple et les responsabilités uniques. Pour les conteneurs, il suffit de pouvoir construire des objets, injecter des dépendances et résoudre les cycles de vie, et il n'est pas nécessaire d'assumer la responsabilité de "vérifier la police" .
Si la vérification dynamique est vraiment requise, il est recommandé de résumer IS_A () dans une fonction d'outil et de le gérer de manière unifiée, comme:
<code> Fonction Assertimplements ($ instance, string $ interface) {if (! is_a ($ instance, $ interface)) {lancez new invalidargumentException ("instance non implémentée interface: $ interface"); }} </code>Cela améliore non seulement la lisibilité, mais réduit également le couplage.
