Quelles sont les caractéristiques ou utilisations élégantes de Perl ?

Question

Quoi ? Perl Beautiful ? Elégant ? C'est une blague !

C'est vrai, il existe des Perl très laids. Et par un peu, je veux dire beaucoup. Nous l'avons tous vu.

Bien sûr, il s'agit d'une soupe aux symboles. N'est-ce pas ?

Oui, il y a des symboles. Tout comme les "mathématiques" ont des "symboles". C'est juste que nous, programmeurs, sommes plus familiers avec les symboles mathématiques standard. Nous avons appris à accepter les symboles de nos langues maternelles, qu'il s'agisse de l'ASM, du C ou du Pascal. Perl a simplement décidé d'en avoir un peu plus.

Je pense que nous devrions nous débarrasser de tous les symboles inutiles. Cela améliore l'aspect du code.

Le langage pour ce faire existe déjà. Il s'appelle Lisp. (et bientôt, perl 6 .)

D'accord, petit malin. En réalité, je peux déjà inventer mes propres symboles. Ils s'appellent fonctions et méthodes. De plus, nous ne voulons pas réinventer APL .

Oh, faux alter ego, tu es si drôle ! C'est vrai, Perl peut être très beau. Il peut aussi être très laid. Avec Perl, TIMTOWTDI .

Alors, quels sont vos morceaux de code Perl les plus élégants ?

Answer 1

Perl facilite l'utilisation de listes/hachures pour mettre en œuvre des paramètres nommés, ce que je considère comme très élégant et comme une aide considérable à l'auto-documentation du code.

my $result = $obj->method(
    flux_capacitance       => 23,
    general_state          => 'confusion',
    attitude_flags         => ATTITUDE_PLEASANT | ATTITUDE_HELPFUL,
);

Answer 2

Mes morceaux préférés de code Perl élégant ne sont pas nécessairement élégants du tout. Ils sont méta-élégant et vous permet de vous débarrasser de toutes les mauvaises habitudes que de nombreux développeurs Perl ont prises. Il me faudrait des heures ou des jours pour les présenter toutes avec le détail qu'elles méritent, mais en voici une courte liste :

• boîte automatique qui transforme les primitives de Perl en objets de première classe.
• autodie qui permet aux modules intégrés de lever des exceptions en cas d'échec (ce qui supprime la plupart des besoins de l'option or die... construire). Voir aussi mon blog autodie y vidéo ).
• Élan qui fournissent une solution élégante, extensible et efficace. correctes d'écrire des classes en Perl.
• MooseX::Declare qui permet d'améliorer la syntaxe lors de l'utilisation de Moose.
• Perl::Critic votre réviseur de code personnel, automatique, extensible et compétent. Voir aussi ce Perl-tip .
• Devel::NYTProf qui me fournit les informations de profilage les plus détaillées et les plus utilisables que j'aie jamais vues dans le domaine de la santé publique. tous langage de programmation. Voir aussi Blog de Tim Bunce .
• PAR Perl Archiver, l'archiveur de Perl, pour regrouper des distributions et même transformer des programmes entiers en fichiers exécutables autonomes. Voir aussi Perl-tip .
• Perl 5.10, qui offre des fonctionnalités étonnantes améliorations des expressions rationnelles , correspondance intelligente , le déclaration de commutation , défini-or, et variables d'état .
• Aumônier le seul éditeur Perl qui intègre les meilleurs éléments de ce qui précède, qui est multiplateforme, et qui est complètement libre et open source.

Si vous êtes trop paresseux pour suivre les liens, j'ai récemment fait une talk at Linux.conf.au sur la plupart des points ci-dessus. Si vous l'avez manqué, il y a un vidéo en ligne (ogg theora). Si vous êtes trop paresseux pour regarder des vidéos, je présente une version considérablement augmentée de l'exposé sous forme de tutoriel à l'OSCON cette année (intitulé faire du Perl correctement ).

Tous nos vœux de réussite,

Paul

Answer 3

Je suis surpris que personne n'ait mentionné la Transformée de Schwartz.

my @sorted =
  map  { $_->[0] }
  sort { $a->[1] <=> $b->[1] }
  map  { [ $_, expensive_func($_) ] }
@elements;

Et en l'absence d'un opérateur de slurp,

my $file = do { local $/; readline $fh };

Answer 4

Disposez-vous d'une liste de fichiers que l'utilisateur souhaite que votre programme traite ? Vous ne voulez pas traiter accidentellement un programme, un dossier ou un fichier inexistant ? Essayez ceci :

@files = grep { -T } @files;

Et, comme par magie, vous avez éliminé toutes les entrées inappropriées. Vous ne voulez pas les ignorer en silence ? Ajoutez cette ligne avant la dernière :

warn "Not a file: $_" foreach grep { !-T } @files;

Imprime un message d'avertissement pour chaque fichier qu'il ne peut pas traiter sur l'erreur standard. La même chose sans utiliser grep se présenterait comme suit :

my @good;
foreach(@files) {
  if(-T) {
    push @good, $_;
  } else {
    warn "Not a file: $_";
  }
}

grep (et map ) peut être utilisé pour raccourcir le code tout en le gardant très lisible.

Answer 5

La construction "ou mourir" :

open my $fh, "<", $filename
    or die "could not open $filename: $!";

L'utilisation de qr// pour créer des grammaires :

#!/usr/local/ActivePerl-5.10/bin/perl

use strict;
use warnings;
use feature ':5.10';

my $non_zero         = qr{[1-9]};
my $zero             = qr{0};
my $decimal          = qr{[.]};
my $digit            = qr{$non_zero+ | $zero}x;
my $non_zero_natural = qr{$non_zero+ $digit*}x;
my $natural          = qr{$non_zero_natural | $zero}x;
my $integer          = qr{-? $non_zero_natural | $zero}x;
my $real             = qr{$integer (?: $decimal $digit)?}x;

my %number_types = (
    natural => qr/^$natural$/,
    integer => qr/^$integer$/,
    real    => qr/^$real$/
);

for my $n (0, 3.14, -5, 300, "4ever", "-0", "1.2.3") {
    my @types = grep { $n =~ $number_types{$_} } keys %number_types;
    if (@types) {
        say "$n is of type", @types == 1 ? " ": "s ", "@types";
    } else {
        say "$n is not a number";
    }
}

Sous-programmes anonymes utilisés pour éliminer le code dupliqué :

my $body = sub {
    #some amount of work
};

$body->();
$body->() while $continue;

au lieu de

#some amount of work
while ($continue) {
    #some amount of work again
}

Tables de répartition basées sur le hachage :

my %dispatch = (
    foo => \&foo,
    bar => \&bar,
    baz => \&baz
);

while (my $name = iterator()) {
    die "$name not implemented" unless exists $dispatch{$name};
    $dispatch{$name}->();
}

au lieu de

while (my $name = iterator()) {
    if ($name eq "foo") {
        foo();
    } elsif ($name eq "bar") {
        bar();
    } elsif ($name eq "baz") {
        baz();
    } else {
        die "$name not implemented";
    }
}