Comment faites-vous du code réutilisable?
Tout code peut être réutilisé d'une manière ou d'une autre, du moins si vous modifiez le code. Le code aléatoire n'est pas très réutilisable en tant que tel. Lorsque je lis certains livres, ils disent généralement que vous devez explicitement rendre le code réutilisable en tenant compte d'autres situations d'utilisation du code. Cependant, certains codes ne doivent pas être omnipotents.
J'aimerais avoir du code réutilisable que je n'aurai pas à changer plus tard. Comment faites-vous du code réutilisable? Quelles sont les exigences pour que le code soit réutilisable? Quels sont les éléments que le code réutilisable devrait avoir et quels éléments sont optionnels?
Voir 10 conseils pour écrire du code réutilisable pour obtenir de l'aide.
- Gardez le code SEC. Dry signifie "ne te répète pas".
- Faire une classe/méthode faire juste une chose.
- Rédigez des tests unitaires pour vos cours ET simplifiez les tests.
- Supprimer la logique métier ou le code principal de tout code de structure
- Essayez de penser de manière plus abstraite et d’utiliser des classes d’interfaces et d’abstract.
- Code pour l'extension. Écrivez un code qui peut facilement être étendu à l’avenir.
- N'écrivez pas de code inutile.
- Essayez de réduire le couplage.
- Être plus modulaire
- Écrire du code comme votre code est une API externe
Si vous adoptez l'approche de développement piloté par les tests, votre code devient uniquement réutilisable en tant que votre refactor en fonction de scénarios à venir.
Personnellement, je trouve que la refactorisation produit constamment un code plus propre que d'essayer de deviner quels scénarios j'ai besoin de coder une classe particulière.
Plus que toute autre chose, la maintenabilité rend le code réutilisable.
La réutilisabilité est rarement un objectif louable en soi. Il s’agit plutôt d’un produit dérivé de l’écriture de code bien structuré, facile à gérer et utile.
Si vous souhaitez créer du code réutilisable, vous essayez souvent de prendre en compte les exigences relatives aux comportements pouvant être requis dans les projets futurs. Peu importe votre niveau de réussite, vous constaterez que ces exigences de protection de l'avenir sont erronées.
D'autre part, si vous commencez avec les exigences de base du projet actuel, vous constaterez que votre code peut être propre, serré et élégant. Lorsque vous travaillez sur un autre projet nécessitant des fonctionnalités similaires, vous allez naturellement adapter votre code d'origine.
Je suggère de rechercher les meilleures pratiques pour votre langage de programmation/paradigme choisi (par exemple, Patterns et SOLID pour les types Java/C #), la littérature de programmation Lean/Agile et (bien sûr) le livre "Code Complete" . Comprendre les avantages et les inconvénients de ces approches améliorera sans cesse votre pratique de codage. Tout votre code deviendra alors réutilisable - mais «par accident», plutôt que par conception.
Voir aussi ici: Rédaction du code maintenable
Pour la plupart des définitions de "réutilisation", la réutilisation de code est un mythe, du moins d'après mon expérience. Pouvez-vous dire que j'ai des cicatrices? :-)
Par réutilisation, je ne veux pas dire prendre des fichiers sources existants et les battre dans la soumission jusqu'à ce qu'un nouveau composant ou service tombe. Je veux dire prendre un composant ou un service spécifique et le réutiliser sans modification.
Je pense que la première étape consiste à vous mettre dans un état d'esprit selon lequel il faudra au moins 3 itérations pour créer un composant réutilisable. Pourquoi 3? Parce que la première fois que vous essayez de réutiliser un composant, vous découvrez toujours quelque chose qu'il ne peut pas gérer. Alors vous devez le changer. Cela se produit plusieurs fois, jusqu'à ce que vous disposiez enfin d'un composant qui semble au moins être réutilisable.
L’autre approche consiste à créer une conception prospective coûteuse. Mais le coût est tout de suite, et les avantages (peuvent) apparaître un peu plus tard. Si votre patron insiste sur le fait que le calendrier actuel du projet domine toujours, cette approche ne fonctionnera pas.
Orientation objet vous permet de refactoriser le code dans les superclasses. C’est peut-être le type de réutilisation le plus simple, le moins coûteux et le plus efficace. L'héritage de classe ordinaire ne nécessite pas beaucoup de réflexion sur les "autres situations"; vous n'avez pas à créer de code "omnipotent".
Au-delà du simple héritage, la réutilisation est quelque chose que vous trouvez plus que ce que vous inventez. Vous trouvez des situations de réutilisation lorsque vous souhaitez réutiliser un de vos propres packages pour résoudre un problème légèrement différent. Lorsque vous souhaitez réutiliser un package qui ne correspond pas exactement à la nouvelle situation, vous avez le choix.
Copiez-le et corrigez-le. Vous devez maintenant proposer des packages presque similaires - une erreur coûteuse.
Rendez l'emballage d'origine réutilisable dans deux situations.
Faites-le simplement pour le réutiliser. Rien de plus. Trop de réflexion sur la "réutilisation" potentielle et sur des "autres situations" non définies peut devenir une perte de temps.
Vous allez écrire divers modules (parties) lors de la rédaction d'un projet relativement volumineux. En pratique, le code réutilisable signifie que vous devez créer des bibliothèques que d'autres projets nécessitant la même fonctionnalité peuvent utiliser.
Donc, vous devez identifier les modules qui peuvent être réutilisés, pour cela
Identifiez la compétence principale de chaque module. Par exemple, si votre projet doit compresser des fichiers, vous aurez un module qui gérera la compression de fichier. Ne PAS faites-le faire plus que UNE CHOSE. Une seule chose.
Ecrivez une bibliothèque (ou une classe) qui gérera la compression de fichier sans avoir besoin de plus que le fichier à compresser, la sortie et le format de compression. Cela découplera le module du reste du projet, ce qui lui permettra d'être (ré) utilisé dans un contexte différent.
Vous ne devez pas obtenir un résultat parfait du premier coup: lorsque vous réutiliserez réellement la bibliothèque, vous découvrirez probablement des défauts dans la conception (par exemple, vous ne l'avez pas rendue suffisamment modulaire pour pouvoir ajouter facilement de nouveaux formats de compression). et vous pouvez les corriger la deuxième fois et améliorer la possibilité de réutilisation de votre module. Plus vous le réutilisez (et corrigez les défauts), plus il devient facile à réutiliser.
La chose la plus importante à considérer est le découplage. Si vous écrivez un code étroitement couplé, la réutilisation du code est la première victime.
Laissez tous les états ou contextes nécessaires en dehors de la bibliothèque. Ajoutez des méthodes pour spécifier l'état dans la bibliothèque.
D'autres ont mentionné ces tactiques, mais ici, elles le sont formellement. Ces trois vont vous aller très loin:
- Adhérez à la Responsabilité unique Principe - Cela garantit que votre classe "ne fait qu'une chose", ce qui signifie qu'il est plus probable qu'elle sera réutilisable pour une autre application qui inclut la même chose.
- Adhérez au Liskov Principe de substitution - il garantit que votre code "fait ce qu'il est supposé sans surprises", ce qui signifie qu'il sera probablement réutilisable pour une autre application nécessitant la même chose.
- Adhérez au principe Ouvert/Fermé - il garantit que votre code peut se comporter différemment sans modifier son source, ce qui signifie qu'il est plus susceptible d'être réutilisé sans modification directe.
Pour ajouter aux éléments mentionnés ci-dessus, je dirais:
- Rendez ces fonctions génériques que vous devez réutiliser
- Utiliser les fichiers de configuration et faire en sorte que le code utilise les propriétés définies dans fichiers/db
- Intégrez clairement votre code dans ces fonctions/classes afin que celles-ci fournissent des fonctionnalités indépendantes et puissent être utilisées dans différents scénarios et définissent ces scénarios à l'aide des fichiers de configuration
J'ajouterais le concept de "Composition de classe sur héritage de classe" (dérivé d'autres réponses ici). De cette manière, l’objet "composé" ne se soucie pas de la structure interne de l’objet dont il dépend - seulement de son comportement, ce qui conduit à une meilleure encapsulation et à une facilité de maintenance (tests, moins de détails à prendre en compte). Dans des langages tels que C # et Java, il est souvent crucial car il n’existe pas d’héritage multiple, il est donc préférable d’éviter le graphe d’héritage.
Comme mentionné précédemment, le code modulaire est plus réutilisable que le code non modulaire.
Une façon d'aider au code modulaire consiste à utiliser l'encapsulation, voir la théorie de l'encapsulation ici: http://www.edmundkirwan.com/
Ed.
Évitez de réinventer la roue. C'est tout. Et cela en soi a de nombreux avantages mentionnés ci-dessus. Si vous avez besoin de changer quelque chose, il vous suffit de créer un autre morceau de code, une autre classe, une autre constante, une bibliothèque, etc.
Commentez, en détail , tout ce qui semble être source de confusion lorsque vous revenez au code la prochaine fois. Des commentaires excessivement verbeux peuvent être légèrement ennuyeux, mais ils sont bien meilleurs que des commentaires épars et peuvent vous épargner des heures d’essai pour vous aider à comprendre ce que vous avez fait la dernière fois.