PHP Master | Refactorisation de code pratique, partie 3 - Extensibilité

Points clés

• Le code évolutif suit une logique réutilisable et claire et un modèle bien connu, et le code modulaire est souvent très évolutif. Le code monomère peut être plus efficace mais est moins évolutif, il peut donc être avantageux de trouver un équilibre entre les deux.
• L'évolutivité logique consiste à utiliser les fonctionnalités linguistiques les plus logiques et les plus communes pour le travail. Pour les solutions complexes, il est recommandé de suivre les modèles de conception standard car ils sont faciles à comprendre et à prendre en compte les développements futurs.
• La conception modulaire implique de diviser les applications en modules, ce qui facilite le développement, l'expansion et la maintenance. Chaque module doit combiner des fonctionnalités et des fonctions pertinentes. Les modules doivent être autonomes autant que possible et minimiser les dépendances pour simplifier le débogage et le déploiement.
• Le découplage et l'encapsulation impliquent la séparation des fonctions, des méthodes et des classes pour améliorer la réutilisabilité et l'évolutivité du code. La réduction des dépendances entre les modules et les composants peut améliorer la disponibilité et l'évolutivité tant qu'elle ne complique pas le code.

Dans la deuxième partie de la série, j'ai partagé quelques questions sur le refactorisation de code pour améliorer la lisibilité. Dans cette section, nous discuterons d'un autre aspect: l'évolutivité. Nous adopterons la même approche de question / discussion pratique que dans la section précédente afin que vous puissiez entrer dans le nouveau monde de refactorisation dès que possible. Le code extensible fait référence aux extraits de code qui suivent des modèles réutilisables, logiquement clairs et bien connus, qu'il s'agisse d'un modèle de conception standard ou d'un flux logique normal. Le code modulaire est souvent très évolutif, tandis que le code monolithique n'est souvent pas évolutif, mais le code monolithique peut être plus efficace. les deux mondes. Les principaux aspects du code extensible dont nous discuterons comprennent: l'évolutivité logique (flux logique normal et motifs de conception), conception modulaire et découplage et encapsulation.

Évolutivité logique

1. La plupart des blocs de code suivent-ils le flux logique normal? Lorsque vous traitez de petits problèmes logiques, assurez-vous d'utiliser la structure correcte (si, pour, foreach, pendant que, etc.). Par «structure correcte», je veux dire que vous devez utiliser les fonctionnalités linguistiques les plus logiques et les plus communes pour ce travail. Par exemple, itérer à travers des tableaux simples devrait utiliser FOREAK; Pour une tâche aussi simple, l'utilisation de ce qui est encore plus inconnu. Vous avez peut-être vos raisons, dans ce cas, rappelez-vous la section précédente sur la documentation des pratiques personnalisées, donc c'est bien.
2. Les solutions complexes suivent-elles les modèles de conception standard? Quand j'ai commencé à utiliser PHP, je ne savais pas grand-chose sur les modèles de conception. Maintenant, je trouve que l'utilisation de modèles de conception est un must pour les grands projets car ils sont faciles à comprendre et prennent en compte les développements futurs. Un problème complexe commun que vous devez résoudre en utilisant un modèle standard bien défini consiste à créer diverses instances d'une certaine classe. Mais pourquoi et quand utiliser le modèle de conception d'usine? Cela peut être controversé, mais les directives générales sont les suivantes: ce modèle peut s'appliquer si vous avez des implémentations différentes de la même interface et que vous devez créer un objet d'implémentation dynamiquement. Un autre cas peut être lorsque de nombreux objets dynamiques de la même classe sont générés, mais le nombre n'est connu qu'au moment de l'exécution. Par exemple, les applications Web modernes à forte intensité de GUI peuvent avoir besoin de créer des lignes d'entrée de formulaire dynamique pour les enregistrements de base de données. Il existe d'innombrables exemples de lorsque les modèles de conception seront utiles.

Design modulaire

1. La structure du code suit-elle la conception modulaire? La conception modulaire signifie que vous divisez votre application en modules. Les applications plus importantes constituées d'applications plus petites sont plus faciles à développer et plus faciles à évoluer et à maintenir. Chaque module doit collecter un ensemble de fonctionnalités et de fonctions pertinentes et les combiner dans une entité. Les fonctions principales et les points d'entrée d'application peuvent également être considérés comme des modules. Vous pouvez ensuite ajouter des fonctionnalités futures en ajoutant de nouveaux modules. Certaines personnes se réfèrent aux modules utilisés de cette manière comme plugins. Cependant, peu importe la conception et la structure que vous choisissez pour votre application, vous devez vous assurer comment les modules / plugins le chargent et les désinstaller, leur structure de base, etc., et considérer ces problèmes avant de développer des modules de base. Chaque fois que vous voyez un groupe de code dans un module agit comme son entité enfant unique et est utilisé par ce module de niveau supérieur avec un minimum de paramètres, pourquoi ne pas le diviser en nouveau module? Habituellement, lorsque j'ai une entité enfant divisée en plusieurs classes pour effectuer des tâches auxiliaires, je n'hésite pas à le déplacer dans un nouveau module. Les modules utilitaires sont une solution intelligente au code orphelin dans des applications modulaires bien conçues. Chaque fois que j'ai du code orphelin, je le déplace dans un module utilitaire qui gère les extraits de code et les petites tâches. Ce module est généralement composé de fonctions et de sous-classes orphelines. Chaque fois que ces tâches sont assez grandes, je commence à les déplacer dans son propre module séparé, ce qui est un processus de refactorisation continu.
2. est le module la moins dépendante? Les modules doivent être autonomes autant que possible. Les dépendances du module souple sont naturelles et bonnes, par exemple, le module "inventaire" dépend du module "comptabilité" pour obtenir un système de commerce électronique homogène, mais de nombreuses dépendances dures sont mauvaises. Ils rendent le débogage et le déploiement plus difficiles. Pour assurer moins de dépendances intermodules, vous devez itérer de temps à autre sur votre base de code pour voir s'il existe des dépendances dures entre les modules. Effacez-les si vous le pouvez et si vous le pouvez, vous devez fusionner les deux modules en un avec un nom plus courant. Par exemple, dans une application de commerce électronique, vous pourriez avoir un module "Projet" et un module de gestion "Inventaire", et les classes en inventaire utilisent de nombreuses classes dans le projet et vice versa. Je fusionnerais les deux et renommerais le module à "inventaire", qui contient un sous-module pour gérer le projet.

Découplage et emballage

1. Les fonctions, les méthodes et les classes sont-elles assez découplées? L'ajout d'une fonction de pagination pour afficher les résultats d'une base de données est une tâche très courante. En fait, au cours de ma première carrière de développement de PHP, j'ai écrit un code pour paginer les résultats; J'ai ensuite décidé de découpler l'algorithme de pagination avec chaque composant avec lequel je l'utilise avec l'utiliser. Chaque fois que vous vous retrouvez à répéter la logique ou le code, vous devrez peut-être faire du découplage pour améliorer la réutilisabilité et l'évolutivité de votre code.
2. Les modules et les composants sont-ils assez découplés? Vous découplez la bonne voie tout en gardant les dépendances au minimum. Il n'y a pas de découplage à 100% entre deux choses connexes; En tant que ligne directrice, découplez jusqu'à ce que les modules et les composants de votre base de code puissent communiquer entre eux sans beaucoup de points communs répétitifs. N'oubliez pas que chaque fois que la complexité n'augmente pas, la réduction de la dépendance est proportionnelle à la disponibilité et à l'évolutivité. Lorsque la complexité commence à augmenter, la relation commence à être inversement proportionnelle.

Résumé

Dans cette section, nous discutons de refactorisation du code d'évolutivité, en se concentrant sur trois aspects principaux: l'évolutivité logique, la conception modulaire et le découplage et l'encapsulation. J'espère que maintenant vous avez commencé à mieux comprendre comment développer et maintenir de meilleures applications. Dans la dernière section, nous discuterons de la façon de refactor pour l'efficacité sans compromettre la lisibilité et l'évolutivité. images de Fotolia

Des questions fréquemment posées sur le refactorisation de code (FAQ)

Quelle est l'importance de la refactorisation du code PHP?

Le refactorisation de code est un processus clé du développement de PHP. Il s'agit de réorganiser le code existant sans modifier son comportement externe pour améliorer les propriétés non fonctionnelles du logiciel. Le refactorisation rend le code plus facile à lire, à maintenir et à étendre. Il aide à identifier et à corriger les erreurs cachées des logiciels et à améliorer ses performances. Cela facilite également la compréhension et le traitement des autres développeurs, augmentant ainsi la productivité globale de l'équipe de développement.

Comment améliorer la lisibilité du code PHP?

Améliorer la lisibilité du code PHP implique une variété de pratiques. Tout d'abord, utilisez des noms significatifs pour les variables, les fonctions et les classes. Deuxièmement, gardez les fonctions et les classes petites et concentrez-vous sur une seule tâche. Troisièmement, utilisez des commentaires pour expliquer l'objectif de pièces de code complexes, mais évitez les commentaires inutiles pour gâcher le code. Enfin, suivez les conventions de codage standard de PHP, telles que l'indentation correcte, l'utilisation des espaces et les conventions de dénomination cohérentes.

Qu'est-ce que l'évolutivité dans le contexte du code PHP?

L'évolutivité dans le code PHP fait référence à la capacité du code à étendre ou à modifier de nouvelles fonctionnalités sans affecter les performances ou les fonctionnalités du système existantes. Ceci est réalisé en écrivant du code modulaire, en utilisant des principes de programmation orientés objet et en suivant des principes solides. Le code extensible est plus facile à maintenir, à mettre à niveau et à développer, ce qui en fait une propriété idéale dans le développement de logiciels.

Comment rendre mon code PHP plus évolutif?

Rendre votre code PHP plus évolutif implique une variété de pratiques. Tout d'abord, écrivez du code modulaire et organisez-le en petites unités indépendantes (modules) qui peuvent être modifiées ou étendues indépendamment. Deuxièmement, utilisez des principes de programmation orientés objet tels que l'encapsulation, l'héritage et le polymorphisme pour créer un code réutilisable et extensible. Troisièmement, suivez les principes solides, qui fournissent des conseils pour la conception de logiciels faciles à maintenir, à comprendre et à étendre.

Quels sont les défis communs dans le refactorisation du code?

Le refactorisation de code peut être difficile pour diverses raisons. Premièrement, cela nécessite une compréhension approfondie des fonctions du code et du logiciel. Deuxièmement, cela peut prendre beaucoup de temps, en particulier pour les grandes bases de code. Troisièmement, s'il ne fonctionne pas correctement, il peut introduire de nouvelles erreurs. Enfin, il peut nécessiter des modifications du processus de test et de déploiement, ce qui peut entraîner des interférences.

Comment surmonter les défis de la refactorisation du code?

surmonter les défis du refactorisation de code implique plusieurs stratégies. Tout d'abord, avant de commencer le processus de refactorisation, obtenez une compréhension plus approfondie des fonctions du code et du logiciel. Deuxièmement, utilisez des outils de refactorisation automatique pour gagner du temps et réduire le risque d'introduire de nouvelles erreurs. Troisièmement, refacteur progressivement le code, en commençant par la petite partie gérable du code. Enfin, assurez-vous d'avoir un processus de test solide pour assister à toutes les erreurs introduites pendant le processus de refactorisation.

Quelles sont les meilleures pratiques de refactorisation de code?

Les meilleures pratiques de refactorisation de code incluent la compréhension du code et de ses fonctions avant de démarrer le processus de refactorisation, de refactorisation progressivement du code, en utilisant des outils de refactorisation automatique et en ayant un processus de test puissant. De plus, il est également important de communiquer avec votre équipe sur le processus de refactorisation et son impact sur le projet.

Comment s'assurer que mon code de refactorisation est exempt d'erreurs?

Assurer que la refactorisation du code est exempte d'erreurs nécessite un processus de test puissant. Utilisez des tests unitaires pour tester les composants individuels de votre code, utilisez des tests d'intégration pour tester comment ces composants interagissent et utilisez des tests système pour tester l'ensemble du logiciel. De plus, des outils de test automatisés sont utilisés pour capturer toutes les erreurs qui peuvent être introduites pendant le processus de refactorisation.

Comment mesurer si le travail de refactorisation du code est un succès?

Il existe de nombreuses façons de mesurer si le travail de refactorisation de code est réussi. Premièrement, le code refactorisé doit être plus facile à lire, à maintenir et à étendre. Deuxièmement, les performances du logiciel doivent être améliorées. Troisièmement, le nombre d'erreurs dans le code doit être réduit. Enfin, l'équipe de développement devrait être plus facile à gérer le code.

Quelles sont les bonnes ressources pour en savoir plus sur le refactorisation de code?

Il existe de nombreuses bonnes ressources pour en savoir plus sur le refactorisation de code. Certains livres populaires sur le sujet incluent «Refactoring: Amélioration de la conception du code existant» de Martin Fowler et «Utilisation efficace du code hérité» de Michael Feathers. De plus, il existe de nombreux tutoriels en ligne, cours et articles sur le refactorisation de code sur des plateformes telles que Coursera, Udemy et Medium.

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!