Perl moderne : 2014

Prenez le contrôle de votre programmation avec le Perl moderne.


précédentsommairesuivant

II. La philosophie Perl

Perl est efficace — il est souple, indulgent et malléable. Des programmeurs expérimentés l'utilisent chaque jour pour tout, depuis des scripts unilignes à usage unique permettant d'automatiser rapidement une petite tâche jusqu'à des projets pluriannuels et multiprogrammeurs.

Perl est pragmatique. Vous détenez le contrôle. Vous décidez comment résoudre vos problèmes et Perl s'adaptera pour faire ce que vous désirez, avec peu de frustration et sans aucune cérémonie.

Perl grandira avec vous. Dans l'heure qui suit, vous allez en apprendre assez pour écrire des programmes réels, utiles et vous comprendrez comment fonctionne le langage et pourquoi il fonctionne ainsi. Modern Perl tire parti de cette connaissance et de l'expérience combinée de la communauté mondiale Perl, pour vous aider à écrire du code fonctionnel et maintenable.

Tout d'abord, vous devez savoir comment apprendre plus.

II-A. Perldoc

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.

http://perldoc.perl.org/ héberge les versions récentes de la documentation Perl. Les index CPAN à http://search.cpan.org/ et http://metacpan.org/ fournissent de la documentation pour tous les modules du CPAN. Les autres distributions telles que ActivePerl et Strawberry Perl fournissent une documentation locale en formats HTML.

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

 
Sélectionnez
$ 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.

Comment lire la documentation

Perl dispose de beaucoup de documentation. Par où commencer ?
perldoc perltoc affiche la table des matières de la documentation principale et perldoc perlfaq affiche la table des matières de la Foire aux Questions sur Perl. perldoc perlop et perldoc perlsyn documentent les opérateurs symboliques et les constructions syntaxiques de Perl. perldoc perldiag explique la signification des messages d'avertissement de Perl. perldoc perlvar répertorie toutes les variables symboliques de Perl. Parcourir ces fichiers vous donnera un bon aperçu du langage.

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.

II-B. Expressivité

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 :

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

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

 
Sélectionnez
my @triples;

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

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

 
Sélectionnez
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.

II-C. Contexte

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

Le contexte de quantité définit combien d'éléments vous attendez d'une opération. L'accord en nombre sujet-prédicat de la langue française représente un parallèle proche. Même sans connaître la description formelle de ce principe linguistique, vous comprenez sans doute l'erreur dans la phrase « Perl sont un langage amusant ». En ce qui concerne le contexte de quantité, on peut dire que le verbe « sont » attend un pluriel. En Perl, le nombre d'éléments que vous demandez détermine combien vous en obtenez.

Supposons que la fonction (Déclarer des fonctionsDéclarer des fonctions) trouver_corvees() trie votre liste de tâches ménagères par ordre de priorité. Le nombre de tâches que vous vous attendez à lire à partir de votre liste détermine exactement ce que la fonction va faire. Si vous ne vous attendez à rien, vous faites juste semblant d'être occupé. Si vous vous attendez à une tâche, vous aurez quelque chose à faire pour le prochain quart d'heure. Si vous avez un sursaut d'énergie sur un week-end, vous pouvez obtenir toutes les tâches.

Lorsque vous appelez une fonction et n'utilisez jamais sa valeur de retour, vous utilisez un contexte void :

 
Sélectionnez
trouver_corvees();

Affecter la valeur de retour de la fonction à un seul élément (ScalairesScalaires) met en œuvre le contexte scalaire :

 
Sélectionnez
my $resultat_unique = trouver_corvees();

L'affectation des résultats de l'appel de la fonction à un tableau (TableauxTableaux) ou à une liste, ou leur utilisation dans une liste évalue la fonction dans un contexte de liste :

 
Sélectionnez
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 () );

Les parenthèses sur la deuxième ligne de l'exemple précédent groupent les deux déclarations de variables (Portée lexicalePortée lexicale) en une seule, afin que l'affectation initialise les deux variables à la fois. Notez que, cependant, une liste contenant un seul objet est toujours une liste. Vous pouvez aussi bien écrire :

 
Sélectionnez
my ($element_unique)   = find_chores();

... auquel cas les parenthèses indiquent à l'analyseur Perl que vous voulez utiliser un contexte de liste pour l'initialisation, même si vous attribuez un seul élément d'une liste. C'est subtil, mais maintenant que vous êtes au courant, la différence de contexte de quantité entre ces deux déclarations devrait être évidente :

 
Sélectionnez
my $contexte_scalaire   = trouver_corvees();
my ($contexte_de_liste) = trouver_corvees();

L'évaluation d'une fonction ou d'une expression — à l'exception de l'affectation — dans un contexte de liste peut générer de la confusion. Les listes propagent le contexte de liste aux expressions qu'elles contiennent. Les deux appels à trouver_corvees() se produisent dans un contexte de liste :

 
Sélectionnez
traiter_liste_de_resultats( trouver_corvees() );

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

Le dernier exemple surprend souvent les programmeurs débutants, car l'initialisation d'une table de hachage (Tables de hachageTables de hachage) avec une liste de valeurs impose à trouver_corvees un contexte de liste. Utilisez l'opérateur scalar pour imposer un contexte scalaire :

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

Pourquoi le contexte est-il important ? Une fonction sensible au contexte peut examiner son contexte d'appel et décider la quantité de travail qu'elle doit faire. Dans un contexte vide, find_chores() peut légitimement ne rien faire. Dans un contexte scalaire, elle peut retrouver juste la tâche la plus importante. Dans un contexte de liste, elle doit trier (opération peut-être chère) et retourner la liste complète triée.

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

L'autre contexte de Perl — le contexte de valeur — détermine la façon dont Perl interprète un fragment des données. Vous avez probablement déjà remarqué que Perl peut déduire si vous avez un nombre ou une chaîne de caractères et convertir des données entre les deux formats. En contrepartie de l'absence de nécessité de déclarer (ou au moins de suivre) explicitement le type de données contenu dans une variable ou produit par une fonction, les contextes de valeurs de Perl fournissent des indices sur la façon de traiter ces données.

Perl contraindra les valeurs aux types spécifiques appropriés (CoercitionCoercition), selon les opérateurs que vous utilisez. Par exemple, l'opérateur eq teste si les chaînes de caractères contiennent la même information sous forme de chaîne :

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

Vous avez peut-être eu une expérience déroutante où vous saviez que les chaînes étaient différentes, mais semblaient identiques lors de la comparaison :

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

Alors que l'opérateur eq traite ses opérandes comme des chaînes en leur appliquant le contexte de chaîne de caractères, l'opérateur == impose un contexte numérique. En contexte numérique, les deux chaînes sont évaluées à 0 (Coercition numériqueCoercition numérique). Assurez-vous d'utiliser l'opérateur approprié pour le type de contexte souhaité.

Le contexte booléen survient lorsque vous utilisez une valeur dans une instruction conditionnelle. Dans les exemples précédents, if évaluait les résultats des opérateurs eq et == dans un contexte booléen.

Dans de rares cas, vous devrez peut-être forcer un contexte explicite là où il n'existe aucun opérateur typé approprié. Pour forcer un contexte numérique, ajoutez zéro à une variable. Pour forcer un contexte de chaîne de caractères, concaténez une variable à une chaîne vide. Pour forcer un contexte booléen, doublez l'opérateur de négation :

 
Sélectionnez
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 contextes de valeur sont plus faciles à identifier que les contextes de quantité. Une fois que vous savez quels opérateurs fournissent quels contextes (Types d'opérateursTypes d'opérateurs), vous ferez rarement des erreurs.

II-D. Idées implicites

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

La variable scalaire par défaut (également appelée topic variable ou variable sujet), $_, est surtout remarquable en son absence : beaucoup d'opérations internes à Perl travaillent sur le contenu de $_ en l'absence d'une variable explicite. Vous pouvez toujours utiliser $_ comme variable, mais c'est souvent inutile.

Beaucoup d'opérateurs internes de Perl (y compris chomp , split chr, ord, lc, length, reverse et uc) travaillent sur la variable scalaire par défaut si vous ne leur fournissez pas une alternative. Par exemple, la commande interne chomp supprime toute séquence de saut de ligne de la fin de son opérande. Voir perldoc -f chomp et $/ pour des détails plus précis sur son comportement.

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

$_ a en Perl la même fonction que le pronom ceci en français. Sans une variable explicite, chomp supprime la séquence finale de saut de ligne de $_. Perl comprend ce que vous voulez dire quand vous dites « chomp » : Perl va toujours chomper ceci. Ces deux lignes de code sont équivalentes :

 
Sélectionnez
chomp $_;
chomp;

De même, say et print fonctionnent sur $_ en l'absence d'autres arguments :

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

Les expressions régulières du Perl (Expressions régulières et correspondanceExpressions régulières et correspondance) utilisent par défaut $_ pour la correspondance, la substitution et la translittération :

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

s/Paquito/Paquita/;

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

Les instructions de boucle du Perl (BouclesBoucles) utilisent par défaut $_ comme variable d'itération. Considérons une boucle for sur une liste :

 
Sélectionnez
say "#$_" for 1 .. 10;

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

... ou une boucle while :

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

… ou la transformation d'une liste avec map :

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

… ou le filtrage d'une liste avec grep :

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

De même que le français (ou l'anglais) peut devenir confus lorsque vous avez trop de pronoms et d'antécédents, il peut arriver la même chose en Perl lorsque vous mélangez des usages explicites et implicites de $_. Si vous l'utilisez dans plusieurs endroits, un morceau de code peut substituer silencieusement la valeur attendue par un autre morceau de code. Par exemple, si une fonction utilise $_ et que vous l'appelez dans une autre fonction qui utilise $_, a valeur 'appelée peut écraser la valeur de l'appelante :

 
Sélectionnez
while (<STDIN>)
{
    chomp;

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

Si calcule_valeur() ou toute autre fonction a modifié $_, ce changement persisterait à travers cette itération de la boucle. À partir de Perl 5.10, vous pouvez déclarer $_ comme une variable lexicale (Portée lexicalePortée lexicale) avec my pour empêcher l'écrasement d'une instance existante de $_ :

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

Malheureusement, cette construction a quelques cas limites liés à la façon dont se comportent les fonctions existantes quand elles s'attendent à ce que $_ soit une variable globale. À partir de Perl 5.18, les Perl 5 Porters considèrent cette fonctionnalité comme expérimentale. Utilisez-la avec prudence. En outre, l'utilisation d'une variable lexicale nommée peut être encore plus claire :

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

Utilisez $_ comme le mot « il » dans l'écriture formelle : avec parcimonie, dans de petits cadres bien définis.

L'opérateur ...

Perl 5.12 introduit l'opérateur triple-point (...) comme un espace réservé pour du code que vous souhaitez compléter plus tard. Perl l'analysera comme une instruction complète à la compilation, mais déclenchera une exception comme quoi vous essayez d'exécuter du code non implémenté si vous tentez de l'exécuter. Voir perldoc perlop pour plus de détails.

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

Perl fournit également deux variables implicites de type tableau. Perl passe des arguments aux fonctions (Déclarer des fonctionsDéclarer des fonctions) dans un tableau nommé @_. Les opérations de manipulation de tableau (TableauxTableaux) à l'intérieur des fonctions ont lieu sur ce tableau par défaut. Ces deux extraits de code sont équivalents :

 
Sélectionnez
sub toto
{
    my $arg = shift;
    ...
}

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

Tout comme $_ correspond au pronom il, @_ correspond aux pronoms ils et eux. Contrairement à $_, Perl localise automatiquement @_ pour vous lorsque vous appelez d'autres fonctions. Les commandes internes shift et pop prennent pour opérande @_, si aucun opérande explicite n'est fourni.

En dehors de toute fonction, la variable tableau par défaut @ARGV contient les arguments de ligne de commande pour le programme. Les opérations sur tableaux en Perl (y compris shift et pop) utilisent implicitement @ARGV en dehors des fonctions. Vous ne pouvez pas utiliser @_ à la place de @ARGV.

L'opérateur readline

L'opérateur <$fh> de Perl est identique à la commande interne readline. readline $fh fait la même chose que <$fh>. Comme à partir de Perl 5.10, une readline basique se comporte exactement comme <>, vous pouvez maintenant utiliser readline partout. Pour des raisons historiques, <> est encore plus fréquent, mais envisagez d'utiliser readline comme une alternative plus lisible. (Qu'est-ce qui est le plus lisible, glob '*.html' ou <*.html>? La même idée s'applique.)

ARGV a un cas particulier. Si vous lisez à partir du descripteur de fichier vide <>, Perl traitera chaque élément de @ARGV comme le nom d'un fichier à ouvrir en lecture. (Si @ARGV est vide, Perl lira depuis l'entrée standard.) Ce comportement implicite de @ARGV est utile pour écrire des programmes courts, tels qu'un filtre de ligne de commande qui inverse son entrée :

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

Pourquoi scalar ? say impose le contexte de liste sur ses opérandes. reverse passe son contexte aux opérandes, en les traitant comme une liste dans un contexte de liste et comme une chaîne concaténée dans un contexte scalaire. Si le comportement de reverse vous semble confus, votre instinct a raison. Perl aurait sans doute dû distinguer les opérateurs « inverser une chaîne » et « inverser une liste ».

Si vous l'exécutez avec une liste de fichiers :

 
Sélectionnez
$ perl reverse_lines.pl encrypted/*.txt

… le résultat sera un long flux de sortie. Sans arguments, vous pouvez fournir votre propre entrée standard en la redirigeant (avec un « pipe ») à partir d'un autre programme ou en tapant directement. C'est une grande flexibilité dans un petit programme, mais Perl ne fait que commencer.


précédentsommairesuivant
« Il y a plus d'une façon de le faire. »

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Licence Creative Commons
Le contenu de cet article est rédigé par chromatic et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Pas de Modification 3.0 non transposé.
Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright © 2013 Developpez.com.