Cours gratuits » Cours informatique » Cours programmation » Cours Perl » Cours Perl complet : variables, tableaux speciaux et structures complexes

Cours Perl complet : variables, tableaux speciaux et structures complexes

Problème à signaler:

Télécharger



★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Cours Perl complet : variables, tableaux spéciaux et structures complexes

Perl est né du besoin de disposer d'un langage optimisé pour l'extraction d'informations de fichiers textes et la génération de rapports. Avant la naissance de Perl, les traitements sur le texte devaient être faits au moyen de scripts shell, en utilisant les programmes sed, awk, grep, cut test et expr. Beaucoup de limites apparaissaient quand on utilisait cette programmation : format des données d'entrée pas toujours souple, difficulté de passer des données d'un processus à l'autre, lenteur due au lancement de multiples programmes (le coût du lancement d'un processus n'était pas négligeable), dépendance à une m

ise en œuvre particulière d'une commande, bugs intrinsèques à certains langages (awk ne différencie pas la comparaison de nombres et de chaînes de caractères). Perl regroupe et emprunte sa syntaxe concrète à tous ces mini langages, dont le shell, en ajoutant une partie de la syntaxe du C et les fonctions des bibliothèques système en C.

Pourquoi Perl est devenu populaire

Portabilité : Perl existe sur la plupart des plateformes aujourd'hui (Unix, Linux, Windows, Mac, )é : disponible sur Internet simplicité : quelques commandes permettent de faire ce que fait un programme de 500 lignes en C ou en Pascal robustesse : pas d'allocation mémoire à manipuler, chaînes, piles, noms de variables illimités

Quelle utilisation?

A l’origine Perl a été créé pour

1 manipuler des fichiers (notamment pour gérer plusieurs fichiers en même temps)

2 manipuler des textes (recherche, substitution)

3 manipuler des processus (notamment à travers le réseau) ⇒ Perl était essentiellement destiné au monde UNIX

Pourquoi utilise-t-on Perl aujourd’hui?

1 conversion de formats de fichiers

2 générer, mettre à jour, analyser des fichiers HTML (notamment pour l’écriture de CGI)

3 accès @@ universelAA aux bases de données ⇒ Perl n’est plus lié au monde UNIX

Perl n’est pas fait pour

1 écrire des interfaces interactives (mais il existe le module tkperl)

2 le calcul scientifique (Perl n’est pas compilé : problème de performances)

Expressions

Comparaisons de chiffres opérateurs habituels :>, >=, <, <=, ==,!=

Attention := est une affectation,== est une comparaison de chaˆınes gt, ge, lt, le, eq, ne

Attention!Ne pas confondre la comparaison de chaˆınes et d’entiers ’b’ == ’a’⇒ évalué comme étant vrai! il faut écrire : ’b’ eq ’a’⇒ évalué faux bien-sˆur

Comparaisons de booléens

Même si le type booléen n’existe pas en tant que tel, des opérateurs existent : || (ou inclusif), && (et),!(négation) (!2 < 1) ⇒ vrai(1 < 2) && (2 < 3) ⇒ vrai($a < 2) || ($a == 2) équivaut à($a <= 2) (!$a &&!$b) équivaut à!($a ||$b) (règle de Morgan!)

Remarque : depuis Perl 5 une notation plus agréable existe :or (au lieu de ||),and (au lieu de &&),not (au lieu de!) if (not ($tropCher or $tropMur)) print "J’achete!";

Syntaxe générale

Les commentaires commencent par un#.

Tout le reste de la ligne est considéré comme un commentaire.

Un bloc est un ensemble d’instructions entourées par des crochets ({}), chaque instruction étant suivie d’un point-virgule.

Procédures et fonctions

Remarque

Le passage de paramètres se fait donc à l’aide du tableau spécial@ (géré par le système Perl).

L’instructionmy réalise une affectation dans des variables locales à la procédure avec les éléments du tableau.

Ce type de passage de paramètre est très efficace car le nombre de paramètres n’est pas forcément fixe.

Les chaines de caractères

Une chaîne de caractères Perl comprend de 0 à n caractères ASCII dont le code est com¬pris entre 0 et 255. Il n’y a donc pas de restriction sur le caractère NUL ou sur les autres caractères non imprimables. Il y a deux manières de spécifier la valeur littérale d’une chaîne:

– utiliser une simple quote comme délimiteur, le contenu est pris tel que, il n’y a pas d’interprétation de caractères particuliers. Dans ce cas pour introduire une simple quote dans la chaîne, il convient de la précéder d’un antislash (\) , pour introduire un antislash, il faut le doubler.

’Bonjour’            une chaîne

’Bonjour \n’       le \n n’a pas de sens ici

’L\’école’            le \ devant ’ pour l’apostrophe

’c:\\windows\\system’ antislash doublés

’’             chaîne vide

– utiliser une double quote comme délimiteur, certaines séquences de caractères se¬ront interprétées. L’antislash (\) est utiliséici comme caractère d’échappement et s’utilise comme suit:

 LES SCALAIRES 5

"\n"       une nouvelle ligne

"\t"        une tabulation

"\033" un caractère codéen octal (33 ici) "\x1F" un caractère codéen hexa (1F ici)

"\cA"     un caractère de Contrôle (Ctrl-A ici)

"\\"        un \

"\""        une double quote

Les chaînes de caractères présentées entre double quotes permettent également d’interpréter le contenu de variables (cf. 2.1.4).

Les opérateurs pour les chaînes de caractères L’opérateur de concaténation est le . (le point) :

"Bonjour"."Monsieur"  <==> "BonjourMonsieur"

’Il’.’ ’."fait beau \n"        <==> "Il fait beau \n"

Les opérateurs de comparaison de chaînes de caractères sont les suivants:

eq (égalité)        ne (différence)

lt (inférieur)       gt (supérieur)

le (inférieur ou égal)      ge (supérieur ou égal)

Les opérateurs q et qq permettent de remplacer respectivement les délimiteurs de chaîne quote et double quote par un délimiteur au choix du programmeur:

$chaine=’S\’il vous plait’;

peut aussi s’écrire

$chaine=q@s’il vous plait@;

C’est le caractère @ qui est ici utilisécomme délimiteur

2.1.3 Les variables scalaires

Une variable scalaire est représentée par une suite de caractère précédée du symbole $. Le premier caractère suivant le $ doit être une lettre, ensuite on peut trouver un nombre quelconque de chiffres et de lettres. Les majuscules et minuscules sont différenciées et le caractère (souligné) est autorisé:

L’affectation des variables scalaires

L’opérateur d’affectation en Perl est le signe =

$I = 10; (affecte la constante 10 à la variable I)

$K = $I + 1; (affectation de I + 1 à la variable K soit 11) $chaine = ’Bonjour’ . ’àtous’; (affectation d’une chaîne)

Les programmeurs SH ou CSH noteront que pour référencer une variable, il convient de précéder son nom par le symbole $ de part et d’autre de l’opérateur d’affectation (le signe =).

Il existe d’autres opérateurs d’affectation, ce sont des raccourcis d’écriture familiers aux programmeurs C:

– affectation et opération combinée

$var += 2;            <==> $var = $var + 2;

$var *= 3;            <==> $var = $var * 3;

$chaine .= ’xxx’; <==> $chaine = $chaine . ’xxx’;

– Incrémentation et décrémentation automatique

$I =        10;                                        

$I++;                     <==>     $I = $I    + 1;        donc I = 11

$K =       ++$I;     <==>     $K = $I  = $I + 1; donc K = I = 12

$K =       $I++;     <==>     $K = $I; donc K =              $I = $I + 1; 12 et I = 13

L’incrément se fait avant l’affectation si l’opérateur précède le nom de la variable (++$I) ou après l’affectation si l’opérateur suit le nom de la variable ($I++).

Interprétation des variables dans une chaine de caractères

Des variables scalaires peuvent être interprétées lorsqu’elles sont contenues dans des chaines de caractères présentées entre double quotes. À cet effet, Perl recherche le ca¬ractère $ et considère ce qui le suit comme un nom de variable potentiel. Si la variable existe, son contenu est intégréà la chaine source, si elle n’existe pas, elle est remplacée par une chaine vide. Il n’y a qu’un seul niveau d’interprétation, si une variable contient elle même une chaine faisant référence à une autre variable, il n’y aura aucun traitement. Pour empécher l’interprétation comme un nom de variable des caractères qui suivent le caractère $, il convient de le précéder d’un antislash ou de placer le morceau de chaine considéréentre simple quotes.

$chaine1 = "Au revoir";

$chaine2 = "$chaine1 les petits amis";

$chaine3 = "au plaisir ";

$chaine4 = "${chaine3}de vous revoir"; Les accolades sont utilisées ici comme en sh, csh pour indiquer explicitement la variable à interpréter.

2.1.5 Des fonctions pour manipuler les scalaires

En plus des opérateurs du langage, Perl propose des fonctions (cf. section 11) adaptées au traitement des variables scalaires, parmi celles-ci citons:

– chop( enlève le dernier caractère d’une chaine;

– chomp( enlève le dernier caractère d’une chaine si celui-ci est un délimiteur de fin de ligne;

– chr( convertit une valeur entière en le caractère correspondant du code ASCII;

– hex( renvoie la valeur décimale correspondant à une chaine de caractères héxadécimaux; – oct( renvoie la valeur décimale correspondant à une chaine de caractère octaux;

– index( renvoie la position de la première occurrence d’une sous chaine dans une chaine;

– lc( convertit une chaine de caractères en caractères minuscules; – length( indique la longueur en caractère d’une variable scalaire;

– rindex( renvoie la position de la dernière occurrence d’une sous chaine dans une chaine;

– substr( permet d’extraire d’une chaine une sous chaine définie en position et lon¬gueur.

CHAPITRE 2. LES TYPES DE DONNÉES

$Esc = chr(27);  # convertit l’entier 27 en ASCII

$B10 = hex("1F3C"); # $B10 vaut 7996

$B10 = oct("1073"); # $B10 vaut 571

$Min = lc("ABCDE"); # $Min vaut "abcde"

$Lg = length($Min); # $Lg vaut 5 (longueur en caractères

$Lg = length($B10); # $Lg vaut 3 d’un scalaire)

2.2 Les tableaux

Une variable de type tableau est une liste de données scalaires (nombres et/ou chaînes). Chaque élément du tableau est une variable scalaire accessible comme telle.

2.2.1 Les éléments d’un tableau

Les valeurs littérales qui peuvent être affectées à une variable de type tableau s’expriment comme une liste de valeurs séparées par des virgules et encadrées par des parenthèses.

()            <==>     tableau vide     

(8,4,9,4,5)           <==>     5             éléments            (des       nombres)

(’toto’,"$var",3)               <==>     3             éléments            (la           chaîne ’toto’,

la valeur courante de    la            variable               $var       et le nombre 3)

Un opérateur de construction liste (..) peut être utilisépour spécifier un élément de ta¬bleau.

(1..10)

<==>     10 éléments      (les nombres de 1 à 10)

(1..5,10,20..30) <==>     16 éléments      (les chiffres de 1 à 5,

                               puis le nombre 10 et les 11 nombres de 20 à 30

($debut..$fin)   <==>     (($fin+1)              -              $debut) éléments ayant

pour valeurs de $debut à $fin par incrément de 1

Les variables tableaux

Le nommage d’une variable tableau suit les mêmes conventions que celui d’une variable scalaire, hormis le premier caractère qui est ici @ (un arobas). C’est le premier caractère qui determine le type de la variable utilisée, si @tab est une variable de type tableau, elle n’a rien à voir avec $tab qui est une variable de type scalaire. Une variable de type tableau qui n’a jamais étéaffectée a pour valeur une liste vide ().

L’affectation des variables tableaux

Le signe égal est l’opérateur d’affectation des variables tableaux.

$I = 5;

@tab1 = ();         <==> @tab1 est vide

@tab2 = (5,3,15); <==> @tab2 contient 3 éléments de

valeurs 5, 3 et 15

@tab1 = @tab2;              <==> @tab1 est une copie de @tab2

@tab2 = $I;        <==> @tab2 reçoit un scalaire et

ne contient plus qu’un seul élément (de valeur 5) ($a,$b,$c) = @tab1; <==> $a = 5; $b = 3; $c = 15; accès aux éléments d’une variable tableau

Les éléments constitutifs d’une variable de type tableau sont des scalaires, la référence à un élément commence donc par le symbole $, un indice expriméentre crochets ([]) indique l’occurrence ciblée. Le premier élément d’un tableau est accessible par l’indice 0.

$I = 5;

@tableau = (’x’,2,3,4,5,’x’);

$tableau[0] = 1;               <==> accès au 1er élément du tableau

$tableau[$I] = 6;              <==> accès au Ième élément

L’indice du dernier élément d’une variable tableau est accessible par la variable sca¬laire $#nom-du-tableau. Si on affecte un élément au delàde cette limite, les trous sont bouchés par des élèments de valeur undef1.

@tab = (10,20,30);

$tab[$#tab+1] = 40; <==> $tab[3] = 40;

$#tab vaut maintenant 3

$tab[10] = 1000;               <==> $#tab vaut maintenant 10, les

éléments intermédiaires $tab[4]..$tab[9] prennent la valeur undef

L’affectation d’une variable tableau dans une variable scalaire rend le nombre d’éléments de la variable tableau:

@tab = (1,2,3,4); $scal = @tab;

# $scal vaut 4

2.2.3 Des fonctions pour manipuler les variables tableaux

Diverses fonctions permettent d’effectuer des décalages, des tris ... sur des listes (des variables tableaux).

Les fonctions push() et pop()

Les fonctions push() et pop() permettent de travailler sur l’extrémitédroite d’une liste (ajout ou suppression d’éléments) :

@liste=(’a’,’b’);

push(@liste,(’c’,’d’,’e’)); <==> @liste=(’a’,’b’,’c’,’d’,’e’)

pop(@liste);      <==> @liste=(’a’,’b’,’c’,’d’)

Les fonctions shift() et unshift()

Les fonctions shift( et unshift( permettent de travailler sur l’extrémitégauche d’une liste (ajout ou suppression d’éléments) :

@liste=(’c’,’d’,’e’);

unshift(@liste,(’a’,’b’)); <==> @liste=(’a’,’b’,’c’,’d’,’e’)

shift(@liste);     <==> @liste=(’b’,’c’,’d’,’e’)

La fonction sort(

La fonction sort( permet de trier une liste dans l’ordre ASCII de ses éléments (les nombres sont convertis en chaînes avant le tri) :

@liste=(100,1,2,58,225);

@tri=sort(@liste); <==> @tri=(’1’,’100’,’2’,’225’,’58’) @liste=(’rouge’,’vert’,’bleu’);

@tri=sort(@liste); <==> @tri=(’bleu’,’rouge’,’vert’)

La fonction reverse(

La fonction reverse( permet d’inverser les éléments d’une liste:

@liste=(1,2,3,4,5);

@rev=reverse(@liste);                <==> @rev=(5,4,3,2,1)

La fonction chop(

La fonction chop( permet de supprimer le dernier caractère de tous les éléments d’une liste. Elle fonctionne également sur une variable scalaire et est surtout utilisée pour sup¬primer les caractères de fin de lignes contenus dans des lignes (résultats de saisies ...) :

@liste=("tutu\n","toto\n");

chop(@liste);    <==> @liste=("tutu","toto")

 La fonction chomp() permet de supprimer le dernier caractère (seulement s’il s’agit d’un délimiteur de fin de ligne) de tous les éléments d’une liste. Il est donc préférable d’utiliser chomp() pour supprimer les éventuels délimiteurs de fin de lignes résultant d’une saisie, d’une lecture de fichier, ...

La fonction qw()

L’affectation de constantes litérales dans un tableau est fréquente et d’une écriture un peu fastidieuse, Perl propose la fonction qw() qui travaille sur une liste de mots:

@liste=("tutu","toto",’machin’); # est équivalent à @liste = qw(tutu toto machin); # ou même à @liste = qw(tutu

toto

machin);

2.3 Les tableaux associatifs (hashes)

Un tableau associatif (ou hash) est un tableau dont les éléments (des scalaires) sont accédés au moyen d’un index qui est une valeur scalaire quelconque. Les éléments d’un hash sont des couples (clef, valeur).

2.3.1 Les variables tableaux associatifs

Le nommage d’un tableau associatif suit les mêmes conventions que celui d’une variable scalaire, hormis le premier caractère qui est ici un % (le caractère pour-cent).

%trad = (’january’,’janvier’,’february’,’avril’);

# On affecte le hash %trad par une liste qui contient un # nombre pair d’éléments correspondant à des couples # clef, valeur.

$trad{’february’}=’fevrier’;

# l’élément du hash %trad dont la clef est ’february’ reçoit # une nouvelle valeur.

Une autre forme peut être utilisée pour spécifier les valeurs d’un tableau associatif, elle met en évidence la correspondance clef/valeur :

%trad = ( ’january’ => ’janvier’, ’february’ => ’fevrier’,

’march’                => ’mars’ );

2.3.2 Des fonctions adaptées aux tableaux associatifs

keys

La fonction keys(%var hashee) rend une liste des clefs d’un hash.

%hash = (’un’,1,’deux’,2,’trois’,3,’quatre’,4); @liste_clef = keys(%hash);

# <==> @liste_clef = (’un’,’deux’,’trois’,’quatre’);

values

La fonction values(%var hashee) rend une liste des valeurs d’un hash.

%hash = (’un’,1,’deux’,2,’trois’,3,’quatre’,4); @liste_val = values(%hash);

# <==> @liste_val = (1,2,3,4);

each

La fonction each(%var hashee) rend un couple clef,valeur dans une liste à deux éléments. Chaque appel de each sur une même variable de type hash rend le couple suivant.

%hash = (’un’,1,’deux’,2,’trois’,3,’quatre’,4); ($clef,$valeur) = each(%hash);

# au 1er appel <==> $clef=’un’; et $valeur=1;

 each est la fonction adaptée pour parcourir entièrement un hash, elle rend une liste vide lorsque la fin du hash est atteinte.

delete

La fonction delete permet de supprimer un élément d’un hash en indiquant sa clef.

%hash = (’un’,1,’deux’,2,’trois’,3,’quatre’,4); delete($hash{’deux’});

...

Les structures de contrôle

Diverses structures de contrôle sont proposées en Perl, elles évaluent une expression et proposent un traitement selon les schémas algorithmiques classiques. L’expression à évaluer est convertie en chaîne, une chaîne non vide ou différente de ”0” correspond à la

valeur vrai. Les opérateurs de comparaison (==,>,gt,...) retournent 1 pour vrai et 0 pour faux (”0” lorsque converti en chaîne), ci-dessous quelques exemples d’expressions vraies ou fausses:

0             <=> faux

"0"         <=> faux, c’est 0 converti en chaîne

’’             <=> faux, chaîne vide

’00’        <=> vrai, différent de 0 ou ’0’

1             <=> vrai

"n’importe quoi" <=> vrai

undef   <=> undef rend une chaîne vide donc faux

Perl permet de structurer des instructions en utilisant des blocs délimités comme en C par les accolades ({}). La structuration en blocs a un impact sur la portée des variables (cf. section 10).

3.1 L’instruction if

La syntaxe générale de l’instruction if est la suivante:

if (expression_ à_évaluer) {

instruction(s) à exécuter si l’expression est vraie } else {

instructions à exécuter si l’expression est fausse

}

Si il n’y a rien de particulier à faire dans le cas ou l’expression est fausse, on peut se passer du else {...}. Par contre même s’il n’y a qu’une seule instruction à exécuter, il convient de la placer dans un bloc {}.

if ($I == 0) { $I++; }          <==> le else est omis

if ((10 == 10) == 1) { ... } <==> vrai car == rend 1 si la condition est réalisée

Le test de plusieurs cas peut être enchainéen utilisant elsif :

if ($Couleur eq "Bleu") { ... }

elsif ($Couleur eq "Rouge") { ... } elsif ($Couleur eq "Vert") { ... } else { ... }

if ($Couleur eq "Noir") { ... }

else if ($Couleur eq "Jaune") <==> erreur de syntaxe, un else doit être suivi par une accolade {

3.2 L’instruction unless

L’instruction unless fonctionne comme un nif (non if: si l’expression est fausse alors faire).

unless ($I > 0) { ... } else { ... }

Un elsif peut suivre un unless, le elseunless n’existe pas.

3.3 Les instructions while et until

Perl dispose d’une structure tant que (while) et d’une structure jusqu’àce que (until).

$I = 0; while ($I <

$I = 0

until ($I ==          10)

10)         {

{              $I++;

$I++;     }

}              <==> tant que I est inferieur à 10

<==> jusqu’àce que

                                                                                                              I soit égal à 10

while     (1)          {              ...            }                                             <==> sans fin

while     ()            {              ...            }                                             <==> sans fin, une expression

inexistante         n’est pas vide !

until       (0)          {              ...            }                                             <==> sans fin

Pour forcer la sortie d’une boucle while ou until sans s’occuper de la condition d’arrêt, on utilise l’instruction last (de la même façon qu’un break en Langage Q. Pour faire évaluer la condition sans avoir dérouléla totalitédes instructions du bloc, on utilise l’instruction nezt.

3.4 L’instruction for

L’instruction for correspond à une boucle pour dans laquelle on fournit une valeur de départ, une expression à évaluer et une expression permettant une réinitialisation (incrément, décrément, ...).

for ($I=0; $I < 10; $I++) { ... }

Dans l’exemple ci-dessus, on affecte 0 à I, on évalue ($I < 10), si c’est vrai on exécute les instructions incluses dans le bloc et on passe à l’incrémentation de I, si c’est faux on passe à l’instruction suivante.

for (;;) { ... }        <==> boucle sans fin, les expressions

ne sont pas obligatoires

Les instructions nezt et last fonctionnent de la même manière que pour while et until (cf. section 3.3).

3.5 L’instruction foreach

L’instruction foreach charge dans une variable les valeurs successives d’une liste et effec¬tue le traitement spécifiédans le bloc d’instructions. Quand la fin de la liste est atteinte, on passe à l’instruction suivante:

foreach $Couleur (’jaune’,’vert’,’bleu’) { ... }

la variable couleur prend successivement les valeurs jaune, vert et bleu

foreach $var (@tableau1, @tableau2, $I, $K, 10) la variable $var prend successivement toutes les valeurs scalaires contenues dans $tableau1 ... jusqu’àla valeur 10

Ici aussi, last provoque une sortie forcée de la boucle et nezt un passage à la valeur suivante.

EXÉCUTER SI L’EXPRESSION PRÉCÉDENTE EST VRAIE OU FAUSSE 19

3.6 Exécuter si l’expression précédente est vraie ou fausse

L’opérateur && permet d’évaluer une expression si celle qui la précède est vraie, l’opérateur 11 permet d’évaluer une expression si celle qui la précède est fausse:

$J = $I % 2 && printf ("I est impair \n");

I modulo 2 vaut 0 ou 1, si 1 le nombre est impair

si 0 le nombre est pair

$J = $I % 2 || printf ("I est pair \n");

Les opérateurs && et 11 peuvent être utilisés pour former des expressions conditionnelles évaluées par l’instruction if:

if (($a == $b) || ($a == $c)) { ... }

Une dernière construction est possible, elle admet 3 expressions séparées par les opérateurs? et:, la seconde est évaluée si la première est vraie, la troisième est évaluée si la première est fausse:

$J = $I % 2 ? printf ("impair \n") : printf ("Pair \n");


36