Perl moderne : 2014

Perl possède une culture de la documentation utile. L'utilitaire perldoc fait partie de chaque installation Perl complète. Toutefois, votre système de type Unix peut nécessiter l'installation d'un paquetage supplémentaire comme perl-doc sur les versions Debian ou Ubuntu de GNU/Linux. L'utilitaire de ligne de commande perldoc affiche la documentation de chaque module Perl installé sur le système, que ce soit un module standard intégré à la distribution ou un module installé séparément à partir du CPAN (Comprehensive Perl Archive Network), ainsi que des milliers de pages de l'abondante documentation Perl de base.

Utilisez perldoc pour lire la documentation d'un module ou une partie de la documentation de base :

$ perldoc List::Util
$ perldoc perltoc
$ perldoc Moose::Manual

Le premier exemple affiche la documentation intégrée dans le module List::Util. Le deuxième exemple affiche un fichier de documentation pure, en l'occurrence la table des matières de la documentation principale. Le troisième exemple affiche un fichier de documentation pure inclus dans une distribution CPAN du module Moose. (MooseMoose). perldoc cache ces détails ; il n'y a aucune différence entre la lecture de la documentation pour une bibliothèque standard comme Data::Dumper, ou une installée à partir du CPAN. Cette cohérence représente un avantage pour vous — la culture Perl valorise tellement la documentation que même les bibliothèques externes ont tendance à suivre le bon exemple de la documentation de base du langage.

Le modèle standard de documentation inclut une description du module, montre des exemples d'utilisation et puis contient une explication détaillée du module et de son interface. Bien que la quantité de documentation varie selon l'auteur, sa forme est remarquablement cohérente.

L'utilitaire perldoc dispose de bien d'autres fonctionnalités (voir perldoc perldoc). Pour rechercher la FAQ Perl, utilisez l'option -q avec un mot clé. Par exemple, perldoc -q sort renvoie trois questions : Comment puis-je trier un tableau par (quelque chose) ?, Comment puis-je trier une table de hachage (éventuellement par valeur et non par clé) ? et Comment puis-je toujours garder mes tables de hachage triées ?.

L'option -f affiche la documentation pour une fonction interne de Perl. perldoc -f sort explique le comportement de l'opérateur sort. Si vous ne connaissez pas le nom de la fonction souhaitée, consultez la liste des fonctions intégrées disponibles dans perldoc perlfunc.

L'option -v recherche une variable interne. Par exemple, perldoc -v $PID affiche la documentation de la variable qui contient l'identifiant du processus du programme en cours. Selon votre shell, il se peut que vous deviez mettre la variable entre des guillemets ou apostrophes.

L'option -l permet à perldoc d'afficher le chemin d'accès au fichier de documentation plutôt que le contenu de la documentation. Sachez qu'un module peut avoir un fichier .pod distinct en plus de son fichier .pm.

L'option -m affiche l'intégralité du contenu du module, code et tout, sans effectuer aucune mise en forme spéciale.

Perl utilise un format de documentation appelé POD, qui est l'abréviation de Plain Old Documentation. perldoc perlpod décrit comment fonctionne POD. D'autres outils POD incluent podchecker, qui valide la structure des documents POD et le module CPAN Pod::Webserver, qui affiche des POD locales en format HTML via un serveur web minimal.

Larry Wall a étudié la linguistique et les langues humaines. Puis il a conçu Perl. Contrairement à d'autres langages conçus autour d'une notion mathématique, Perl prend en compte la façon dont les gens communiquent. En retour, vous obtenez la liberté de décider comment organiser vos programmes pour répondre à vos besoins. Vous pouvez écrire du code simple et direct d'un seul tenant ou combiner plusieurs petits morceaux en programmes plus vastes. Vous pouvez choisir parmi les multiples modèles de programmation et pouvez éviter ou accepter des fonctionnalités avancées.

Là où d'autres langages affirment qu'il devrait y avoir une seule meilleure façon de résoudre un problème, Perl vous permet de décider ce qui est plus lisible, plus utile, plus attrayant ou plus amusant.

Les passionnés de Perl ont un slogan pour cela: TIMTOWTDI, prononcé « Tim Toady », ou « There's more than one way to do it ! » (2).

Bien que cette expressivité permette aux orfèvres de créer des programmes étonnants, elle permet également à l'imprudent de faire des dégâts. L'expérience et le bon goût vous guideront pendant la conception de votre code, mais le choix vous appartient toujours. Exprimez-vous, mais gardez à l'esprit la lisibilité et la maintenabilité, en particulier pour ceux qui viendront après vous.

Apprendre Perl ressemble à l'apprentissage d'une langue naturelle. Vous apprendrez quelques mots, puis enchaînerez des phrases et puis profiterez de conversations simples. La maîtrise vient de la pratique de la lecture et l'écriture du code. Vous n'avez pas à comprendre tous les détails de Perl pour être productif, mais les principes énoncés dans ce chapitre sont essentiels à votre croissance comme programmeur.

Les débutants en Perl trouvent souvent opaques certaines constructions syntaxiques. Ces idiomes (Expressions idiomatiquesExpressions idiomatiques) offrent une puissance formidable (mais subtile) aux programmeurs expérimentés, mais vous pouvez parfaitement vous permettre de les éviter jusqu'à ce que vous soyez à l'aise avec eux.

Un autre objectif ayant présidé à la conception du langage a été d'essayer d'éviter de surprendre les programmeurs (Perl) expérimentés. Par exemple, l'ajout de deux variables ($first_num + $second_num) est évidemment une opération numérique (Opérateurs numériquesOpérateurs numériques) ; l'opérateur d'addition doit traiter les deux variables comme des valeurs numériques pour produire un résultat numérique. Peu importe le contenu de $first_num et $second_num, Perl les contraindra à des valeurs numériques (Coercition numériqueCoercition numérique). Vous avez exprimé votre intention de les traiter comme des nombres en utilisant un opérateur numérique. Perl le fait volontiers.

Les adeptes de Perl appellent souvent ce principe DWIM, ou do what I mean 3« Fais ce que je veux dire. ». Vous pourriez aussi bien dire que Perl suit le principe de moindre surprise. Même avec une compréhension rudimentaire de Perl (notamment le ContexteContexte), il devrait être possible de comprendre l'intention d'une expression Perl inconnue. Vous allez développer cette compétence pendant l'apprentissage du Perl.

L'expressivité du Perl permet aux débutants d'écrire des programmes utiles sans avoir à comprendre tout le langage. Perl a été conçu pour cela ! Les développeurs expérimentés appellent souvent le résultat du Baby Perl (« Perl du bébé »). Il s'agit d'un terme affectueux, car tout le monde commence un jour comme débutant. Par la pratique et en apprenant des programmeurs plus expérimentés, vous comprendrez et adopterez des idiomes et techniques plus puissants. Il est normal d'écrire un code simple que vous comprenez. Continuez à pratiquer et Perl deviendra en quelque sorte votre seconde langue maternelle.

Un expert en Perl pourrait tripler les nombres d'une liste en utilisant :

my @triples = map { $_ * 3 } @nombres;

... et un adepte du Perl pourrait écrire :

my @triples;

for my $nombre (@nombres)
{
    push @triples, $nombre * 3;
}

... alors qu'un débutant pourrait essayer :

my @triples;

for (my $i = 0; $i < scalar @nombres; $i++)
{
    $triples[$i] = $nombres[$i] * 3;
}

Chacun de ces programmes fait la même chose, mais ils utilisent Perl d'une manière différente.

En devenant plus à l'aise avec Perl, vous pouvez demander au langage d'en faire plus pour vous. Avec l'expérience, vous pouvez vous concentrer sur ce que vous voulez faire, plutôt que comment faire. Pourtant, Perl exécutera volontiers tant le Baby Perl que le Perl de l'expert. Vous pouvez concevoir et affiner vos programmes pour plus de clarté, expressivité, réutilisation et maintenabilité, en partie ou en totalité. Profitez de cette souplesse et du pragmatisme : c'est beaucoup mieux d'accomplir efficacement votre tâche maintenant que d'écrire un programme conceptuel pur et beau l'année prochaine.

Dans les langues parlées, la signification d'un mot ou d'une phrase peut dépendre de la façon dont vous l'utilisez ; le contexte local permet de clarifier l'intention. Par exemple, la pluralisation inappropriée dans « S'il vous plaît donnez-moi un hamburgers ! ». La pluralisation du sujet diffère de la quantité et sonne faux, tout comme le genre incorrect de « la chat ». L'article est féminin, mais le substantif est masculin et cela fait sourire les francophones de naissance. D'autres mots ont des exceptions bizarres. Il est (ou était) par exemple admis que les mots « orgue », « délice » et « amour » étaient masculins au singulier et féminins au pluriel (la règle est moins simpliste que cela, mais on s'en contentera ici). Ce qui a permis par exemple à un humoriste d'écrire : «  Cet orgue est le plus beau de toutes celles que j'ai entendues ».

Le contexte en Perl est similaire. Il décrit la quantité ainsi que le type de données à utiliser. Perl va faire ce que vous entendez faire des données si vous choisissez le contexte approprié pour ces données.

Par exemple, plusieurs opérations en Perl produisent des comportements différents selon que vous attendez zéro, un, ou plusieurs résultats. Une construction spécifique en Perl peut faire quelque chose de différent si vous écrivez, « Fais ceci, mais je ne me soucie pas du résultat » par rapport à « Fais ceci et donne-moi plusieurs résultats ». D'autres opérations vous permettent de spécifier si vous souhaitez travailler avec des données numériques, textuelles ou booléennes.

Le contexte peut être difficile si vous essayez d'écrire ou de lire du code Perl comme une série d'étapes simples isolées. Ce n'est pas comme cela que Perl fonctionne ! Chaque expression fait partie d'un contexte plus large. Vous pourriez vous taper le front après une longue session de débogage lorsque vous découvrez que vos hypothèses sur le contexte étaient incorrectes. Si au contraire vous êtes au courant du contexte, votre code sera plus correct et plus propre, souple, et plus concis.

II-C-1. Contexte vide, scalaire et de liste▲

trouver_corvees();

my $resultat_unique = trouver_corvees();

my @tous_les_resultats        = trouver_corvees();
my ($premier_element, @reste) = trouver_corvees();

# liste des résultats passés à une fonction
traiter_liste_de_resultats( trouver_corvees () );

my ($element_unique)   = find_chores();

my $contexte_scalaire   = trouver_corvees();
my ($contexte_de_liste) = trouver_corvees();

traiter_liste_de_resultats( trouver_corvees() );

my %resultats =
(
    operation_economique => $resultats_economiques,
    operation_couteuse   => trouver_corvees(), # OUPS!
);

my %resultats =
(
    operation_economique => $resultats_economiques,
    operation_couteuse   => scalar trouver_corvees(),
);

II-C-2. Contextes numériques, de chaîne et booléen▲

say "Désastre cryptographique!" if $alice eq $bob;

my $alice = 'alice';
say "Désastre cryptographique!" if $alice == 'Bob';

my $numeric_x =  0 + $x;  # force le contexte numérique
my $stringy_x = '' . $x;  # force le contexte de chaîne de caractères
my $boolean_x =    !!$x;  # force le contexte booléen

Les programmeurs qui connaissent les raccourcis linguistiques de Perl peuvent regarder un bout de code et comprendre instantanément ses caractéristiques les plus importantes. En plus des contextes, Perl possède des variables par défaut — l'équivalent en programmation des pronoms.

II-D-1. La variable scalaire par défaut▲

my $oncle = "Bob\n";
chomp $oncle;
say "'$oncle'";

chomp $_;
chomp;

print;  # affiche $_ dans le descripteur de fichier courant
say;    # affiche "$_\n" dans le descripteur de fichier courant

$_ = 'Mon nom est Paquito';
say if /Mon nom est/;

s/Paquito/Paquita/;

tr/A-Z/a-z/;
say;

say "#$_" for 1 .. 10;

for (1 .. 10)
{
    say "#$_";
}

while (<STDIN>)
{
    chomp;
    say scalar reverse;
}

my @carres = map { $_ * $_ } 1 .. 10;
say for @carres;

say 'L'heure du brunch !'
    if grep { /pâte à crêpes/ } @garde_manger;

while (<STDIN>)
{
    chomp;

    # MAUVAIS EXEMPLE
    my $modif = calcule_valeur( $_ );
    say "Original: $_";
    say "Modifié  : $modif";
}

while (my $_ = <STDIN>)
{
    ...
}

while (my $line = <STDIN>)
{
    ...
}

II-D-2. Les variables tableau par défaut▲

sub toto
{
    my $arg = shift;
    ...
}

sub toto_explicites_args
{
    my $arg = shift @_;
    ...
}

while (<>)
{
    chomp;
    say scalar reverse;
}

$ perl reverse_lines.pl encrypted/*.txt