J'ai une base de code Perl, et il y a beaucoup de fonctions redondantes et elles sont réparties sur de nombreux fichiers.
Y a-t-il un moyen pratique d'identifier ces fonctions redondantes dans le codeBase? Y a-t-il un outil simple qui peut vérifier mon codeBase pour cela?
4 Réponses :
Ce n'est peut-être pas pratique, mais le meilleur outil pour cela est votre cerveau. Parcourez tout le code et obtenez une compréhension de ses interrelations. Essayez de voir les modèles communs. Ensuite, refacteur!
J'ai été tagué votre question avec " refactoring ". Vous trouverez peut-être un matériau intéressant sur ce site déposé sous ce sujet.
J'aime le refacteur de style de chambre à stock. 1. Vérifiez le code dans Git. 2. Assurez-vous que vous avez beaucoup de tests. 3. Renommez le module dans l'intégralité de quelque chose d'inutilisable. 4. Créez un vide. 5. Copier les fonctions en arrière, refactoring leur autant que vous allez, jusqu'à ce que les tests passent à nouveau. 6. Après un mois de ne pas avoir besoin de copier des fonctions de l'ancien module, supprimez-le.
@Ether: Vous avez raison sur le refactoring ... mais je dois d'abord localiser les fonctions .. :)
Si vous êtes sur Linux, vous pouvez utiliser Voici un exemple trop simplifié: P> grep code> pour vous aider à répertorier toutes les fonctions de votre codeBase. Vous aurez probablement besoin de faire ce que l'éther suggère et réussit vraiment le code pour le comprendre si vous ne l'avez pas déjà fait. grep -r "sub " codebase/* > function_list
Si vous travaillez avec Perl, envisagez d'utiliser ack , une version PURE-PERL de grep qui tire parti du support de regex plus puissant de Perl.
Vous pouvez utiliser le B :: XREF Module pour générer une référence croisée rapports.
Je rencontre moi-même dans ce problème dans le passé. J'ai giflé un petit programme rapide qui utilise PPI pour trouver des sous-routines. Il normalise le code un peu (Whitespace normalisé, commentaires supprimés) et signale les doublons. Fonctionne assez bien. PPI fait tout le levage lourd.
Vous pouvez rendre la normalisation un peu plus intelligente en normalisant tous les noms de variable dans chaque routine à $ A, $ B, $ C et peut-être peut-être quelque chose de similaire pour les chaînes. Dépend de la manière dont vous voulez être agressif. P>
#!perl
use strict;
use warnings;
use PPI;
my %Seen;
for my $file (@ARGV) {
my $doc = PPI::Document->new($file);
$doc->prune("PPI::Token::Comment"); # strip comments
my $subs = $doc->find('PPI::Statement::Sub');
for my $sub (@$subs) {
my $code = $sub->block;
$code =~ s/\s+/ /; # normalize whitespace
next if $code =~ /^{\s*}$/; # ignore empty routines
if( $Seen{$code} ) {
printf "%s in $file is a duplicate of $Seen{$code}\n", $sub->name;
}
else {
$Seen{$code} = sprintf "%s in $file", $sub->name;
}
}
}
Agréable! Mais pourquoi avez-vous besoin d'ignorer les routines vides?
Le but n'est pas seulement de trouver du code redondant, mais d'aider dans sa suppression. Il était rapidement évident de courir que la signalisation des routines vides était simplement fouillée. Il n'y a rien de mal avec sub FOO {} . Lorsque vous pensez à l'alternative * foo = \ & do_nothing , qui est aussi stupide que mon $ foo = $ vide_string , il devrait tout avoir de sens.
Je ne suis pas vraiment sûr de ce que vous voulez dire quand vous dites "redondants". Parlez-vous de plusieurs sous-marins que tous font le même travail? Ou sur les sous-marins qui ne sont jamais appelés? Ou les deux?