Question de conception de Perl

Question

Quelle est la différence entre la rédaction de sous-fonctions et tout mettre dans un fichier par rapport aux packages d'écriture? L'objet est-il meilleur que la procédure en matière de perl?

Fondamentalement, à la recherche d'exemples de scénarios où OO est meilleur que la procédure.

Merci!

Answer 1

Tout d'abord, juste pour clarifier, la différence entre la procédure et l'OO n'est pas la même que la différence entre mettre tout votre code dans un seul fichier par rapport à le mettre dans des modules distincts. Vous pouvez avoir des modules distincts pleins de fonctions que vous appelez procédural.

L'utilisation de modules, OO ou procédural, est avantageux, c'est si le code va être réutilisé ou s'il ne s'agit qu'une grande base de code. Si vous avez un CMS avec 10 scripts CGI différents qui font tous plusieurs des mêmes choses, comme la vérification d'une session utilisateur peut-être, alors mettre ce code dans un module distinct plutôt que de le réécrire dans chaque CGI est logique. S'il s'agit d'une fonction de 20 lignes spécifique à ce script, laissez-la dans le même fichier.

Que ce soit avec OO ou la procédure dépend de ce que vous faites. La plupart des gens vont favoriser la majorité du temps ces jours-ci. Je suis d'accord avec eux car je pense que cela vous aide à réfléchir à votre code logiquement et à regrouper les choses d'une manière saine qui sera facile à gérer et à mettre à jour plus tard.

Answer 2

J'aime mettre autant de mon code que possible dans les modules. La bonne chose à propos des modules est que vous pouvez utiliser les outils de test de Perl (prouver et tester :: plus) pour écrire et gérer facilement les tests unitaires. Donc, si presque tout votre code est en modules, presque tout est testable.

Lorsque j'écris un script, j'aime avoir un wrapper mince qui analyse les options de configuration et de ligne de commande dans mon script (probablement en utilisant des modules comme config :: any ou getOpt :: long). Le script contient également un usage sous-programme. J'ajoute alors un main sous-programme. main est très simple:

sub main {
    my $cfg = shift;

    my @collected_data;

    for my $file ( @{ $cfg->{files} ) {
        eval {
            my $fh = get_handle_from_file($file);

            my $xyz_data = parse_xyz_data( $fh );

            push @collected_data, extract_data( $xyz_data, $cfg->{filter} );

            1;
        } or do {
            my $e = $@;
            $e = "an unknown error occurred" unless defined $e;

            warn "Error parsing '$file': $e\n";
        };        
    }

    my %summary_data = summarize_data( @collected_data );

    write_summary( $cfg->{summary_target} );

    return;
}

Presque tous les sous-programmes de soutien vivraient dans un ou plusieurs modules.

La POO est un bon moyen d'associer les données et le comportement. Cela peut rendre le code plus lisible et réduire l'encombrement.

 $foo->eat_something( $sandwich )

est plus facile à comprendre que:

 eat_something( $sandwich, $likes_salty, $likes_sour, $likes_sweet, $likes_spicy );

Toutes les conneries supplémentaires sont regroupées à portée $foo Attributs d'objet et voyagent sans encombrer l'appel sous-marin.

Bien sûr, vous pourriez faire:

eat_something( $foo, $sandwich )

Où $ foo n'est qu'un hachage ordinaire de préférences gustatives. C'est essentiellement ce que fait Perl oo, de toute façon. L'invocant (objet ou nom de classe) est passé comme le premier argument à chaque méthode. Vous perdez un espacement de noms, des appels de noms, des héritances et des méthodes dynamiques. Sur les trois coûts, les espaces de nom pratiques seront le plus cruellement manqué. IMO, l'héritage est surfait et ne doit être utilisé que rarement. Les appels de méthode dynamique peuvent être pratiques pour les mêmes raisons que les tables de répartition sont pratiques.

Il n'y a rien que vous ne puissiez pas faire dans OO Perl que vous ne pouvez pas faire dans Perl Procédural. Mais, OO rend certaines choses très pratiques.

Permettez-moi de fermer en réécrivant mon script mythique dans le style OO (je vais aller un peu par-dessus bord sur l'OO, juste pour l'illustration):

sub Main {my $ cfg = shift;

    my $cd = Data::Collection->new();

    for my $file ( $cfg->files ) {
        eval {

            # skip the step of creating a handle first.  The parsing object
            # can take a file and get a handle or could be passed a handle.               

            my $xyz_parser = File::XYZ::Parse->new( file => $file );

            # The parser returns an XYZ::Data object

            my $xyz_data = $xyz_parser->parse;

            $cd->add_data( $xyz_data->extract_data( $cfg->filter );

            1;
        } or do {
            my $e = $@;
            $e = "an unknown error occurred" unless defined $e;

            warn "Error parsing '$file': $e\n";
        };        
    }

    # Skip the step of separate summarization, since the cd object can check if
    # the summary has been done, and if not generate and cache it as needed.

    $cd->write_summary( $cfg->summary_target );

    return;
}