Combien de code dupliqué avez-vous tolérer?
Dans une récente revue de code, j'ai repéré quelques lignes dupliquées logique dans une classe (au moins 15 lignes). Quand j'ai suggéré que l'auteur de refactoriser le code, il a fait valoir que le code est plus simple à comprendre de cette façon. Après avoir lu le code, encore une fois, je suis d'accord à l'extraction de la copie de la logique nuirait à la lisibilité un peu.
Je sais SEC d'une recommandation, pas une règle absolue. Mais en général, êtes-vous prêt à faire mal lisibilité dans le nom de la SEC?
- Les sondages comme cela devrait être de la communauté wiki.
- Autant de fois que je suis prêt à corriger le bug. En d'autres termes, aucun/jamais/nada/nul/nulle.
- Pourriez-vous fournir un peu de code? Il est difficile pour moi de penser à un code dupliqué qui a l'air mieux qu'un non-doublé d'un
- Je ne peux pas copier le code ici en raison de la propriété intellectuelle. Mais la question est, en partie, de ne pas être en mesure de nommer l'abstraction avec quelque chose de significatif et donc de rendre le code plus difficile à comprendre. Je vais essayer de revenir avec un exemple.
- if (str == null || str.length() == 0) vs isStringNullOrEmpty(str) qui est mieux, je sais ce qui est plus facile à taper et plus. Je sais qui est plus descriptive et plus facile à gérer si je veux ajouter un autre test. Si une ligne de code peut être remaniée pour une fonction qui est plus descriptif, je ne peux pas imaginer à 25 ans de programmation 15 lignes de code qui ne peut pas être nommé à une fonction.
- Je n'ai même pas permettre à des personnages en double! =P
- Eh bien, je ne sais pas. Comment dupliquer beaucoup de code pouvez-vous tolérer?
- isStringNullOrEmpty est moins descriptive, lorsque vous voulez ajouter un autre test". Ce code est juste un mauvais exemple en général.
- - Je accepter une réponse à un certain point. Depuis que cette question est subjective, je vais accepter la réponse avec le plus de votes. Merci à tous pour votre très précieuse.
- Une fois, j'ai eu des problème avec un code comme cela, c'était une combinaison de tout/pause et de code supplémentaire dans des endroits différents. Faire classe parent et 4 enfants de classes de rendre le code un peu plus compliqué.
Vous devez vous connecter pour publier un commentaire.
Refactoring: l'Amélioration de la Conception de Code Existant
La Règle de Trois
Trois grèves et vous refactoriser.
des Codeurs au Travail
Je tolère aucun. J'ai peut-être certains en raison de contraintes de temps ou autres joyeusetés. Mais je n'ai toujours pas trouvé un cas où le code dupliqué est vraiment justifiée.
Disant que ça va faire mal la lisibilité seulement suggère que vous êtes mal à choisir les noms 🙂
Personnellement, je préfère garder le code compréhensible, d'abord et avant tout.
SEC est à propos de l'assouplissement de la maintenance dans le code. Rendre votre code moins compréhensible afin de supprimer du code à répétition fait mal à la maintenabilité de plus, dans de nombreux cas, que d'avoir quelques répétées de lignes de code.
Cela étant dit, je suis d'accord que la sécheresse est un bon objectif à suivre, lors de la pratique.
Si le code en question a clairement des affaires ou de la technologie de support P, vous devez généralement à refactoriser. Sinon, vous avez le problème classique avec cloné code: finalement, vous découvrirez un besoin de modifier le code de l'appui P, et vous ne trouverez pas tous les clones qui l'implémentent.
Certaines personnes suggèrent de 3 ou plus de copies est le seuil de refactoring. Je crois que si vous avez les deux, vous devriez le faire, trouver un autre clone(s) [ou même en sachant qu'ils peuvent exister dans un grand système est difficile, si vous avez deux ou trois ou plus.
Maintenant cette réponse est fournie dans le contexte de ne pas avoir tous les outils pour trouver les clones. Si vous pouvez trouver de manière fiable des clones, puis le motif original de refactoriser (en évitant les erreurs de maintenance) est moins persausive (l'utilité d'avoir un nom abstrait est toujours vrai). Ce que vous voulez vraiment est un moyen de trouver et de suivre les clones; abstraction est une façon de s'assurer que vous pouvez "trouver" (par la prise de constatation triviale).
Un outil qui permet de trouver des clones de manière fiable peut au moins vous empêcher de faire échec à la mise à jour-clone des erreurs de maintenance. Un tel outil (je suis l'auteur) est le CloneDR. CloneDR trouve des clones à l'aide de la langue ciblée structure d'orientation, et se trouve ainsi clones indépendamment des espaces de mise en page, les changements dans les commentaires, renommé les variables, etc. (Il est mis en œuvre pour un grand nombre de langues, y compris en C, C++, Java, C#, COBOL, PHP). CloneDR trouverez des clones à l'échelle de grands systèmes, sans la moindre orientation. Détecté clones sont affichés, ainsi que le antiunifier, qui est essentiellement l'abstraction que vous avez écrit à la place. Versions de celui-ci (pour COBOL) intègrent désormais avec Eclipse, et vous montrer que vous êtes l'édition à l'intérieur d'un clone dans un tampon, ainsi que là où les autres sont des clones, de sorte que vous pouvez vérifier/modifier les autres pendant que vous êtes là. (Une chose que vous pouvez faire est de refactoriser :).
J'ai l'habitude de penser que le clonage était juste carrément mauvais, mais les gens le font parce qu'ils ne savent pas comment le clone varient par rapport à l'original et donc la finale de l'abstraction n'est pas clair au moment où le clonage de loi est en cours. Maintenant, je crois que le clonage est bon, si vous pouvez suivre les clones et que vous essayez de refactoriser après l'abstraction devient clair.
Dès que vous vous répétez rien vous êtes en train de créer de multiples lieux de faire des modifications si vous trouvez que vous avez fait une erreur, besoin de le proroger, de modifier, de supprimer ou de tout autre des dizaines d'autres raisons que vous pourriez trouver à l'encontre de cette force de changement.
Dans la plupart des langues, l'extraction d'un bloc à un bien nommé méthode peut rarement faire mal à votre lisibilité.
Il est de votre code, vos normes, mais ma réponse à votre "combien?" est aucun ...
vous n'avez pas dit quelle langue, mais dans la plupart des IDEs c'est une simple Refactor -> Extrait de la Méthode. Comment beaucoup plus facile, c'est que, et une méthode unique avec des arguments est beaucoup plus facile à gérer que 2 blocs de code dupliqué.
Très difficile à dire dans l'abstrait. Mais ma propre croyance, c'est que même une seule ligne de code dupliqué doit être faite dans une fonction. Bien sûr, je ne suis pas toujours d'atteindre ce standard élevé moi-même.
Refactoring peut être difficile, et cela dépend de la langue. Toutes les langues ont des limites, et parfois une version remaniée de copies de la logique peut être linguistiquement plus complexe que le code à répétition.
Souvent des duplications de code LOGIQUE de se produire lorsque deux objets, avec les différentes classes de base, ont des similitudes dans la façon dont ils fonctionnent. Pour l'exemple 2 composants GUI que les deux valeurs d'affichage, mais ne pas mettre en œuvre une interface commune pour accéder à cette valeur. Refactoring de ce type de système nécessite des méthodes prenant plus générique d'objets que nécessaire, suivie par le typage et de moulage, ou bien la hiérarchie de classe doit être repensée & restructuré.
Cette situation est différente si le code est exactement reproduite. Je ne voudrais pas nécessairement la création d'une nouvelle classe d'interface si je ne l'a destiné à être utilisé deux fois, et deux fois dans la même fonction.
Le point de SEC est la facilité de maintenance. Si le code est plus difficile à comprendre, il est plus difficile à maintenir, alors si refactoring mal de lisibilité, vous pourriez être en omettant de répondre à SEC de l'objectif. Pour moins de 15 lignes de code, je serais enclin à être d'accord avec votre camarade de classe.
En général, non. Pas pour des raisons de lisibilité, de toute façon. Il y a toujours un moyen de refactoriser le code dupliqué dans une intention de révéler méthode commune qui se lit comme un livre, de l'OMI.
Si vous voulez faire un argument pour violation de la SEC afin d'éviter d'introduire des dépendances, qui peut transporter plus de poids, et vous pouvez obtenir Ayende du journalisme d'opinion opinion avec code pour illustrer le point de ici.
À moins que votre dev est en fait Ayende si je tiens bien à SEC et obtenez la meilleure lisibilité grâce à l'intention révélant les méthodes.
BH
J'accepte PAS de code dupliqué. Si quelque chose est utilisé dans plus d'un endroit, il fera partie du cadre ou au moins un utilitaire de bibliothèque.
La meilleure ligne de code est une ligne de code non écrit.
Cela dépend vraiment de beaucoup de facteurs, combien le code est utilisé, la lisibilité, etc. Dans ce cas, s'il y a une copie du code, et il est plus facile à lire de cette façon, alors c'est peut-être bien. Mais si vous avez besoin d'utiliser le même code dans un troisième lieu, je voudrais envisager sérieusement de refactoring dans une fonction commune.
La lisibilité est l'une des choses les plus importantes de code peut avoir, et je ne suis pas disposé à faire des compromis sur elle. Le code dupliqué est une mauvaise odeur, pas un péché mortel.
Cela étant dit, il y a des questions ici.
Si ce code est censé être la même, plutôt que par coïncidence, le même, il y a une maintenabilité des risques. J'aimerais avoir des commentaires dans chaque lieu de pointage à l'autre, et si il faut être en troisième lieu, je serais à refactoriser out. (En fait, je dois avoir ce code, dans deux programmes différents, qui ne partagent pas approprié fichiers de code, donc les commentaires en chaque point du programme à l'autre.)
Vous n'avez pas dit si les lignes en faire un tout cohérent, l'exécution d'une fonction, vous pouvez facilement décrire. S'ils le font, refactoriser de l'en sortir. C'est rare d'être le cas, puisque vous acceptez que le code est plus lisible incorporé dans deux endroits. Cependant, vous pourriez regarder pour une plus grande ou plus petite similitude, et peut-être facteur d'une fonction pour simplifier le code. Tout simplement parce que d'une douzaine de lignes de code sont répétées ne veut pas dire qu'une fonction ne consistent en ce que la douzaine de lignes et rien de plus.