Un texte en entrée, lire les mots de ce texte, ranger les mots dans un dictionnaire.

Un programme Perl est un fichier texte, et c'est perl qui se charge de l'interpréter puis de l'exécuter. Sous système UNIX, pour être exécuté un script, Perl doit avoir la structure suivante:

#!<chemin vers interpréteur>/<nom de l'interpréteur>

<listes de commandes>

Il faut indiquer sur la première ligne l'interpréteur qui va être utilisé pour exécuter la liste de commandes. Pour perl, on a donc (installation standard) :

#!/usr/local/bin/perl

<listes de commandes Perl>

Sur d'autres systèmes, ou l'interaction minimale n'est pas faite via un shell (comme MACINTOSH ou WINDOWS qui sont uniquement graphiques), cette information n'est pas nécessaire et cette ligne n'est pas prise en compte.

Le caractère # est utilisé pour commenter les programmes. Pour chaque ligne, exceptée la première pour un script écrit sous UNIX, tout ce qui suit ce caractère n'est pas considéré comme faisant partie du langage.

Pour aller plus loin : Un premier programme

Les variables Perl (les scalaires) permettent d'encoder plusieurs types de données simples. Les identificateurs sont de la forme $<chaîne>, où <chaîne> est une suite de caractères qui ne doit pas contenir d'opérateur prédéfini de Perl.

Il n'existe qu'un seul type de donnée simple: les scalaires. Ce type de donnée permet de mémoriser des entiers, des chaînes de caractères et des réels. Les identificateurs sont de la forme $<suite de caractères>.

A partir de ce type simple, on compose deux types complexes:

- tableau de scalaires;

- tableau associatif de scalaires.

Deux choses importantes à savoir à propos des variables:

Il n'est pas nécessaire d'initialiser les variables, une valeur initiale dépendante du contexte leur est affectée lors de leur création. Mais, cela signifie que toute faute de frappe (par exemple $ficheir au lieu de $fichier) ne provoquera pas forcément d'erreur mais donnera certainement un mauvais résultat puisqu'une nouvelle variable va être créée et utilisée.

La gestion de l'allocation de la mémoire est automatique et dynamique. n n'est pas nécessaire de connaître a priori la taille des données que le programme va manipuler.

Un scalaire permet de représenter aussi bien des nombres, entiers ou réels que des chaînes de caractères. Les scalaires commencent par le caractère $. Aux opérateurs classiques de manipulation de nombres, s'ajoute l'opérateur ' . ' (point) qui effectue la concaténation de deux chaînes. Ce sont ces opérateurs qui déterminent le type du contenu de la variable.

Pour des données numériques, les guillemets ne sont pas nécessaires. On obtient un résultat identique si on écrit $a="152" ou $a=152. Une variable placée entre deux guillemets (") dans une affectation est remplacée par sa valeur. Si l'on veut éviter cela, on déspécialise le caractère $ à l'aide du caractère '\'.

$numfigure = 12 ;

$p1 = "...voir figure $numfigure pour..."

$p1 contient " . . . voir figure 12 pour . . . "

$p2 = "...voir Figure \$numfigure pour..."

$p2 contient " . . . voir figure $numfigure pour . . . "

La variable $_ est une variable prédéfinie particulière. On l'utilise pour stocker des informations fréquemment utilisées (dans la plupart des cas comme variable de boucle) et par défaut quand, dans certaines fonctions ou structures de contrôle, une variable est omise.

Pour aller plus loin : scalaires

Tableau

Un tableau de scalaires est une liste de scalaires indexée par un entier. On fait référence à l'ensemble du tableau en préfixant l'identificateur de la variable par @. La référence à un élément particulier du tableau, qui est un scalaire, se fait en préfixant l'identificateur par un $ et en ajoutant entre crochets ([ et ]) l'indice de l'élément. On peut affecter tous les éléments d'un tableau d'un seul coup. Dans ce cas, le tableau est une liste d'éléments séparés par des virgules entre parenthèses.

L'opérateur $# donne l'indice du dernier élément du tableau et permet donc de connaître le nombre d'éléments contenus dans un tableau (indice du dernier élément + 1).

Un tableau associatif est une structure qui permet de mettre en relation deux éléments de type scalaire. C'est un ensemble de couples de scalaires où l'un des éléments (la clé) référence l'autre (la valeur). En pratique on considérera un tableau associatif comme un tableau classique où l'indice n'est pas un entier mais un scalaire. On accède à l'ensemble du tableau en préfixant l'identificateur par le caractère %. Pour accéder à un élément particulier, qui est un scalaire, on préfixe l'identificateur par un $ et on ajoute, entre accolades la valeur de l'indice.

Pour aller plus loin : tableaux

Pour aller plus loin : split

Pour aller plus loin : tableaux associatifs

Un programme Perl, comme un programme C, est une suite d'instructions terminées par un point-virgule. Pour les structures de contrôle (while, if, . . . ) les blocs de programmes sont obligatoirement délimités par des accolades ouvrantes et fermantes: { et }.

La commande < PTR_FICHIER >, où PTR_FICHIER est un pointeur de fichier, permet d'accéder à un fichier. Les éléments du fichier sont lus soit ligne par ligne, en affectant le résultat de la commande à un scalaire:

$variable = <PTR_FICHIER>;

soit dans leur ensemble, en affectant le résultat de la commande à un tableau:

@tableau = <PTR_FICHIER>;

Dans ce cas, chaque élément du tableau correspond à une ligne. On crée le pointeur d'un fichier à l'aide de la commande:

open(PTR_FICHIER,<nom du fichier sur disque>);

Cette commande permet d'ouvrir un fichier en lecture, il ne faut donc pas oublier de refermer le fichier après utilisation:

close(PTR_FICHIER);

Pour créer un fichier ou pour écraser un fichier déjà existant, il faut faire précéder le nom du fichier par un chevron fermant:

open(PTR_FICHIER,"><nom du nouveau fichier sur disque>");

On écrit dans un fichier à l'aide de la commande print:

print $PTR_FICHIER "cette chaine est ecrite dans un fichier\n";

Il existe cependant des fichiers prédéfinis:

• <STDIN> Entrée standard. Ce pointeur permet de lire (et uniquement de lire) le flux d'entrée du clavier.
• <> Désigne tous les fichiers donnés en argument au programme (ou l'entrée standard si aucun fichier n'est spécifié).
• <STDOUT> Sortie standard. Ce pointeur permet d'écrire sur l'écran. C'est le pointeur par défaut de la commande print. L'instruction print STDOUT "..." est équivalente à print " . . . ".

Pour aller plus loin : entrée-sortie

On appelle bloc une ou plusieurs instructions, suivies par des points-virgules et obligatoirement encadrées par des accolades {. . . }.

{

Instruction1;

Instruction2;

Instruction3;

}

La syntaxe utilisée pour les expressions est presque identique à celle utilisée en C. Cependant, le fait d'utiliser des variables non fortement typées impose des opérateurs différents selon le type de test à effectuer. On distingue ainsi deux groupes d'opérateurs selon le type de variable: les variables représentant des chaînes de caractères, celles représentant des nombres, entiers ou non. Pour les valeurs numériques, les opérateurs sont identiques à ceux du C. Nous indiquons ci-dessous les opérateurs de chaînes de caractères.

• eq : $a eq $b est vrai si les deux chaînes sont égales;
• ne : $a ne $b est vrai si les deux chaînes sont différentes;
• lt : $a lt $b est vrai si $a est plus petite que $b au sens lexicographique;
• le : $a le $b est vrai si $a est plus petite ou égale que $b au sens lexicographique;
• gt : $a gt $b est vrai si $a est plus grande que $b au sens lexicographique;
• ge : $a ge $b est vrai si $a est plus grande ou égale que $b au sens lexicographique.

On peut, comme en C, combiner plusieurs expressions à l'aide de "&&" (et) et de " || " (ou) ou utiliser la négation " ! ". Une chaîne vide, ou la valeur O (ce qui revient au même pour un scalaire), a pour valeur faux.

1.

if ( expression)

bloc

2.

if ( expressionl )

bloc 1

else ( expression2 )

bloc 2

3.

if ( expressionl )

bloc 1

elsif ( expression2 )

bloc 2

.....

elsif ( expressionk )

bloc k

else

bloctoutfaux

1. Si l'expression est évaluée à vrai, alors bloc est exécuté;

2. Si l'expression est évaluée à vrai, alors bloc 1 est exécuté, sinon bloc 2 est exécuté;

3. Si l'expression i est évaluée a vrai alors le bloc i est exécuté; si aucune expression n'est vraie alors le bloc tout faux est exécuté.

while ( expression)

bloc

Le bloc est exécuté tant que l'expression expression est évaluée a vrai.

foreach variable (tableau)

bloc

Affecte itérativement les Valeurs du tableau à la variable variable.

Pour aller plus loin : conditions

Pour aller plus loin : contrôles

Perl offre la possibilité d'utiliser le langage des expressions régulières au travers d'opérateurs ou de fonctions.

Cet opérateur peut être comparé à l'effet de la commande UNIX grep sur un fichier d'une seule ligne.

$phrase = ~/<expression régulière>/

a pour valeur vrai si l'expression régulière apparaît dans la variable $phrase.

$phrase = ~s/<expression régulière>/<motif de remplacement>/<options>

remplace dans la variable $phrase la ou les occurrences de l'expression régulières par le motif de remplacement.

Pour aller plus loin : recherche expression régulière

Pour aller plus loin : remplacement expression régulière

Pour aller plus loin : manuel expression régulière