Quelle est une bonne pratique de code pour savoir quand créer une fonction / méthode pour de petits segments de code répétitifs?

Plusieurs fois au cours de l'écriture de programmes plus importants, je me suis demandé après combien de copies et de colles est-il sensé de mettre le code dans une fonction ou une méthode et quelle est la bonne règle de base? J'ai utilisé une règle empirique de quatre lignes ou plus et apparaissant plus de deux fois, puis j'ai créé une fonction / méthode simple contenant ce code. Pouvez-vous penser à une meilleure pratique ou offrir des conseils? Il s'agit plus d'une question générale sur le modèle de conception que d'une question spécifique à la langue.

J'utilise des fonctions en partie pour documenter le code. L'appel d'une fonction avec un nom significatif facilite la compréhension du code. Dans certains cas, même une fonction avec une seule ligne est logique.

Par exemple, dans "Clean Code", Robert C. Martin donne l'exemple suivant: Lequel préférez-vous voir? Cette:

// Check to see if the employee is eligible for full benefits
if ((employee.flags & HOURLY_FLAG) &&
    (employee.age > 65))

Ou ca?

if (employee.isEligibleForFullBenefits())

Je ne suis pas toujours d'accord avec lui, mais dans ce cas, je le fais. Le code doit être lisible, non seulement lorsque vous l'écrivez et que vous connaissez tous les détails, mais également à 21 heures lorsque vous devez corriger des bogues dans le code de quelqu'un d'autre. Il n'est pas recommandé de regarder longtemps et d'essayer de comprendre tous les doubles négatifs. Si vous pouvez simplement mettre un nom dessus (non seulement des conditions, mais chaque morceau de code que vous écrivez), cela devient beaucoup plus simple.

Je n'ai jamais regretté de mettre quelque chose dans une fonction, et si vous êtes inquiet pour les performances, alors profilez d'abord.

Il existe un malentendu répandu selon lequel les appels de fonction ne doivent être effectués que pour éviter les segments de code répétitifs. Ma règle d'or est que toute unité logique de travail doit être transformée en fonction, même lorsqu'elle n'est utilisée qu'en un seul endroit. Cela conduit généralement à une meilleure lisibilité et vous permet d'écrire du code auto-documenté, où les noms de fonction remplacent les commentaires et vous n'avez pas besoin d'écrire des commentaires supplémentaires expliquant ce que vous faites.

S'il est utilisé dans plus d' un endroit, et

• il est susceptible de changer, ou
• il est difficile de bien faire les choses

en faire ensuite une fonction ou une méthode. D'après mon expérience, de longs morceaux de code répétés tomberont naturellement dans l'une de ces catégories (généralement la première, mais les catégories se chevauchent beaucoup;). Bien sûr, tout ce qui doit être dans l'interface est également une fonction / méthode à part entière.

Presque toujours, surtout si chaque doublon représente la même opération d'un point de vue conceptuel. Si elle est effectuée de la même manière, mais sur des types différents, effectuez une implémentation générique.

La seule raison pour laquelle je ne pense pas à cela est la maintenance: parfois, il pourrait être plus pratique d'éviter de créer une dépendance entre des choses distinctes, même au prix d'une certaine duplication.

Une recherche de « refactoring » vous mènera à de nombreuses ressources pour les «meilleures pratiques» de l'industrie pour ce processus très courant. L'article un peu célèbre, Once and Only Once est une excellente référence historique expliquant ce que certains considèrent comme des "meilleures pratiques" pour les préoccupations soulevées par votre question. En outre, le concept encore plus général est connu sous le nom de Don't Repeat Yourself (DRY) . Pour un ensemble de réponses vraiment approfondies à votre question, lisez le grand classique de Martin Fowler , Refactoring: Improving the Design of Existing Code , qui couvre certains des conseils les plus connus en matière de refactoring , ce que vous essayez intuitivement d'accomplir. !

Si le code est répété exactement à plusieurs reprises et que la section répétée ne changera pas dans un avenir proche, je le décompose en fonction.

Cela dépend de la nature de la cohésion du code répété. Si la section répétée du code exécute une fonction spécifique, alors c'est un excellent candidat pour être transformé en une méthode, en partie à cause du principe DRY , en partie parce que si la fonction doit être optimisée ou corrigée, alors il n'y a qu'une seule section de code à traiter.

Si l'association est une coïncidence, il est préférable de répéter le code plutôt que d'en faire une méthode. Si vous devez ajouter quelque chose au milieu de l'une des séquences de code pour satisfaire l'une des utilisations de cet extrait, s'il se trouve dans une méthode, la modification que vous apportez peut affecter d'autres utilisations de cette méthode.

Voir l'article Wikipedia sur le concept de cohésion de code .

Vous devez faire la distinction entre les fonctions au sens de programmation structurée et les méthodes d'une classe.

Dans votre exemple, ce que vous avez montré est une méthode en tant que telle ne doit pas être codée en ligne.

vous devrez peut-être valider une chaîne pour voir s'il s'agit d'un nombre ou non, dans ce cas, vous utilisez une fonction et la plupart des réponses précédentes s'appliquent.

Cette distinction est particulièrement importante dans les grands projets.

Dans la mesure du possible, essayez de séparer les règles métier (qui sont des méthodes) des algorithmes de calcul (qui sont de simples fonctions de programmation).