Débuter avec le langage de programmation Perl


Télécharger Débuter avec le langage de programmation Perl

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

Télécharger aussi :


 

Pierre-François Bonnefoi        Qu‘est ce que PERL ?

PERL signifie “Practical Extraction and Report L anguage”.

Que l’on pourrait (essayer de) traduire par « langage pratique d‘extraction et d’édition ». Créé en 1 9 8 6 par L arry Wall (ingénieur système).

C‘est :

•     Un langage de programmation (il a les mêmes possibilités que C, de l’objet comme C+ + … )

•     Un logiciel gratuit (que l’on peut se procurer sur Internet notamment)

•     Un langage interprété :

–    pas de compilation (en interne : une phase de pré-compilation)

–    moins rapide qu‘un programme compilé (mais implémente les meilleurs algorithmes en interne)– chaque « script » nécessite d’avoir l‘interpréteur Perl sur la machine pour s’exécuter.

Pourquoi Perl est devenu populaire :

•     portabilité : Perl existe sur la plupart des plateformes aujourd‘hui (Unix, V MS , Windows, Mac,Amiga, Atari )

•     gratuité : disponible sur Internet

•     simplicité : Quelques commandes permettent de faire ce qu’un programme de 5 0 0 lignes en C ouen Pascal faisait.

•     robustesse : Pas d‘allocation mémoire à manipuler, chaînes, piles, noms de variables illimités

« PERL est un langage qui vous aide à faire votre travail » L arry Wall

« Il est conçu pour simplifier les tâches faciles, sans rendre les tâches difficiles impossibles. »

Pourquoi Perl ?

Il possède de nombreuses qualités :

•     optimisé pour traiter des fichiers textes (il permet de générer et d’analyser des fichiers textes, autorise une organisation « humaine » de l’information)

•     idéal pour les tâches d’administration système (il dispose de points d’accès vers toutes les fonctions et possibilités d’Unix)

•     possède une syntaxe proche du C, des shell Unix ( “Sh”), des outils d’analyse (“awk”, “grep”, “sed”… )

•     indépendant de la gestion mémoire des données (peut traiter n’importe quelle taille de fichiers, de données… )

•     dispose d’un vaste choix de modules pré-écrits dans de nombreux domaines (interrogation de base de donnée avec SQL , programmation web en CGI, réalisation d’interface graphique avec Tk, programmation réseau… )

•     autorise la réalisation rapide des programmes puissants (prototypage) pouvant tourner sur différentes machines

•     s’adapte au style du programmeur (différents moyens de faire un même travail suivant la sensibilité du programmeur)

•     manipule tout type de données (du binaire à un texte organisé autour de « phrases »).

•     gére « facilement » tout type de fichier et les informations qui les concernent (date, droit d’accès… )

•     lance des processus (lancement d’une application, éventuellement en parallèle)

•     contrôle ces processus (récupére les « sorties » et injecte les « entrées » d’un processus) • …

Schéma de conception de PERL

L angages de programmation (C, C+ + , ADA, Pascal… ) Manipulation/Traitement de données complexes

L angages de commande (Sh, CSh, Bash, Ksh… ) Manipulation de Fichiers/Répertoires

L ancement de processus (Commande, Pipeline)

Utilitaires de conversion/Formatage (grep, sed, awk… ) Conversion de chaînes (“pattern matching”)

Traitement de Fichiers ligne à ligne (“reporting”)

Fusion des fonctionnalités

 

Un programme de base

#!/usr/local/bin/perl

#

# programme tout bete

# print ’Salut le monde.’; # Affiche un message

L a première ligne

Tous les programmes en Perl commence avec cette ligne :

#!/usr/local/bin/perl

•     Elle peut varier d’un système à un autre.

•     Elle indique à la machine ce qu’elle doit faire quand le programme est exécuté (ie, elle lui indiqued’exécuter le programme avec le Perl).

Commentaires et instructions

L es commentaires peuvent être insérés dans un programme en les précédant du symbole # :

–    tout ce qui suivra ce symbole jusquà la fin de la ligne sera ignoré.

–    la seule manière d’étendre un commentaire sur plusieurs lignes est de commencer chaque ligne par # .

L e reste correspond aux  instructions en Perl, qui doivent se terminer par un point-virgule.

Un programme de base (suite et fin)

Simple affichage

L a fonction print renvoie des informations.

• Elle affiche la chaîne de caractère “Salut le monde”, • L ’instruction se termine par un point-virgule.

Exécution du programme

Édition du source du programme avec un éditeur (Emacs par exemple) et création d’un fichier texte contenant ce source

Transformation du source en exécutable :

chmod u+x nom_du_programme

Exécution du programme obtenu :

perl nom_du_programme

./nom_du_programme nom_du_programme

Exécution du programme en mode « avec alarmes »  :

perl -w nom_du_programme

Exécution du programme en mode « déboguage » :

perl -d nom_du_programme

Données scalaires

•     Chaînes de caractères : encadrées par “, ‘ (quote) ou ` (back-quote)fonctionnement similaire aux shells Unix :

–    dans une chaîne encadrées par deux “, les variables sont interpolées

–    dans une chaîne encadrées par deux ‘, les variables ne sont pas interpolées

–    dans une chaîne encadrées par deux ` , le contenu de lachaîne est le résultat de l’exécution de laligne de commande

•     Nombres

–    Exemples : 1 2 3 1 2 3 .4 5 1 2 3 .4 5 e1 0 0 xffff (valeur héxadécimal) 0 7 5 5 (valeur octale)– L a conversion nombre vers chaîne et vice-versa est automatique et dépend des opérations appliquées

•     Booléen V rai ou Faux

–    Un scalaire est interprété à False dans un contexte booléen (un test par exemple) si c’est unechaîne vide ou le nombre 0 ou son équivalent en chaîne “0 ”. – L es autres valeurs sont considérées comme vraies !

•     V aleurs defined ou undefined

–    Il existe deux types de scalaires nuls : defined et undefined. L a fonction defined() peut êtreutilisée pour déterminé ce type

–    undefined correspond à un renvoi d’erreur (fin de fichier, variable non initialisée… ).

V ariables scalaires « $ var »

Notation

L es scalaires sont précédés du caractère $

$nom_de_variable $i = 0; $c = ’a’;

$mon_fruit_prefere = ’kiwi’;

$racine_carree_de_2 = 1.41421;

$chaine = ’100 grammes de $mon_fruit_prefere’;

–   initialisation par défaut : valeur undefined (“0 ” ou chaîne vide)

–   pas de déclaration

–   attention au déboguage !

–   donc pas de type !

–   attention aux fautes d’orthographes !

–   globales par défaut (la variable est visible dans tout le programme)

–   les noms des variables sont composés de chiffres, lettres et souligné (_ ), mais ils ne doivent pascommencer par un chiffre, et la variable $ _ est reservée.

–   Perl est sensible à la casse (différence minuscule, majuscule), $ a et $ A sont deux variables distinctes.

Exemples

Chaînes

 

‘coucou’

# coucou

‘c\’est pas gagné!’

# c’est pas gagné !

‘A bientôt \n’

# A bientot \n

“A bientôt \n”

# A bientôt suivi d’un retour à la ligne

` ls *.back`

# le résultat de l’exécution de la ligne de commande ls *.back

Interpolation de variables dans une chaîne

$ var = “appréc”;

$ variable = “beau”;

print “C’est $ variable”;         # c’est beau print “C’est $ {var}iable”;      # c’est appréciable print ‘c’est $ variable’;    # c’est $ variable

Interchangeabilité nombres ~ chaîne de caractères

$ valeur = ‘9 ’;

$ calcul = $ valeur * 6 ;

                              print “$ calcul”;                       # affiche 5 4

Opérations et assignements

Pour les nombres :

$ a = 1 + 2 ;

# Ajoute 1 à 2 , et l‘affecte à $ a

$ a = 3 - 4 ;

# Soustrait 4 à 3 , et l’affecte à $ a

$ a = 5 * 6 ;

# Multiplie 5 et 6 , et l‘affecte à $ a

$ a = 7 / 8 ;

# Divise 7 par 8 , et affecte 0 ,8 7 5 à $ a

$ a = 9 ** 1 0 ;

# Eleve 9 à la dixième puissance

$ a = 5 % 2 ;

# L e reste de 5 divise par deux (division euclidienne)

+ + $ a;

# Incrementation de $ a, puis on retourne la valeur $ a

$ a+ + ;

# On retourne la valeur $ a puis incrementation de $ a

--$ a;

# Décrementation de $ a, puis on retourne la valeur $ a

$ a--;

# On retourne la valeur $ a puis décrementation de $ a

Opérateurs logiques :

                           &&             # Et logique

                           ||               # Ou logique

                           !                  # Non logique

                            $ a = $ b || “1 0 ”;     # affecte la valeur de $ b à $ a, si cette valeur est définie sinon la chaîne “1 0 ”

Opérations et assignements (suite et fin)

Pour les chaînes de caractères :

Concaténation :

$ a = $ b . $ c; # Concaténation de $ b et $ c Répétition :

                                                                    $ a = $ b x $ c;           # $ b repété $ c fois

$ succés = “hip ” x 3 . “hourra”; # donne “hip hip hip hourra” Extraction :

$ a = substr(“hourra”, 1 , 2 ) # donne “ou” Position index :

$ a = index(“hourra”, “ou”); # donne 1 Conversion binaire :

$ chaîne = pack(“cccc”, 6 5 , 6 6 , 6 7 , 6 8 ); # donne “ABCD” Affectation de plusieurs lignes directement depuis le source du programme :

$ str = < < IDENTIFICATEUR; une ligne, une autre ligne… IDENTIFICATEUR

 Comment assigner une valeur à une variable :

                            $ a = $ b;              # Assigne $ b à $ a

                            $ a + = $ b;          # Ajoute $ b à $ a

                             $ a -= $ b;            # Soustrait $ b à $ a

                             $ a .= $ b;             # Contatene $ b à $ a

L istes et tableaux @

Représentation littéral

                            (1 , 2 , 3 )                            # la liste des éléments 1 , 2 et 3

                              (“coucou”, 4 .5 )                 # une liste peut contenir différents types d’éléments

                           (1 ..3 )                                # équivalent à (1 , 2 , 3 )

L e .. signifie de tant à tant

                             (3 .3 .. 6 .1 )                     # équivalent à (3 .3 , 4 .3 , 5 .3 )

                            ()                                        # la liste vide

                              ($ var, “mot”)             # la liste composée du contenu de la variable var et de “mot”

L es variables de type tableaux Notation

@nom_ du_ tableau

Exemples

@fruits  = (“pommes”, “poires”, “cerises”);

@musique = (“pipo”, “violon”);

                                          @alphabet = (‘a’..‘z’)                 ;

@cartes = (‘0 1 ’..‘1 0 ’,‘V alet’,‘Dame’,‘Roi’);

Il est possible d’affecter un tableau à un autre

@A = @B;

@tab = (1 , 2 , 3 );

@TAB = (4 , 5 , 6 );



@chiffres = (0 , @tab, @TAB, 7 , 8 , 9 );

Accés aux éléments d’un tableau @

Par l’affectation :

@tab = (1 , 2 , 3 );

($ a, $ b, $ c) = @tab; # $ a vaut 1 , $ b vaut 2 et $ c vaut 3 ($ a, @TAB) = @tab # $ a vaut 1 et @TAB vaut (2 , 3 ) ($ a, $ b) = ($ b, $ a) # et hop une permutation !

Par l’indice : Comme en C, l’indice commence à 0 !

@tab = (1 , 2 , 3 );

                             $ a = $ tab[0 ];              # $ a contient 1

Attention quand on accéde à un tableau on manipule un scalaire d’où le $ au lieu du @ !

                              $ b = $ tab[$ a];           # $ b contient 2

                             $ d = $ tab[1 0 ];            # $ d contient undefined

On peut sélectionner des tranches de tableaux

@nouveau_tableau = @tab[0, 2]; # @nouveau_tableau contient (1, 3)

                                 @tableau = @tab[0 .. 2 ];                 # @tableau contient (1 , 2 , 3 )

Bornes du tableau :

$ # tab représente l’indice supérieur du tableau @tab

$ [tab représente lindice inférieur du trableau @tab

$ nb_ element = $ # tab - $ [tab - 1 ;

$ nb_ element = scalar (@tab);

Modification et accés aux tableaux @

Opérateurs push() et pop () : L e tableau vu comme une “pile”

@tab = (1 , 2 );

$ a = 3 ;

@tab = (@tab, $ a);

# ajoute le contenu de la variable $ a au tableau @tab

push (@tab, $ a);

# réalise la même opération : ajout par la droite du tableau

push (@tab, 4 , 5 , 6 );

# @tab = (1 , 2 , 3 , 4 , 5 , 6 );

$ b = pop ( @tab );

# supprime l’élément le plus à droite du tableau

# @tab = (1 , 2 , 3 , 4 , 5 ) et $ b = 6

Opérateur shift() et unshift() : ajout et suppression par la gauche

@tab = (2 , 3 ); $ a = 1 ; unshift(@tab, $ a); # @tab = (1 , 2 , 3 ) unshift(@tab, -1 , 0 ); # @tab = (-1 , 0 , 1 , 2 , 3 ) $ b = shift(@tab); # @tab = (0 , 1 , 2 , 3 )  et $ b = -1

Inversion et tri d’un tableau

@tab = (1 , 3 , 5 , 0 , 2 , 4 );

@tab = reverse(@tab);        # @tab = (4 , 2 , 0 , 5 , 3 , 1 ) @tab = sort(@tab);    # @tab = (0 , 1 , 2 , 3 , 4 , 5 )

                                    @tabstr = (“petit, “moyen”, “grand”);   # @tabstr = (“grand”, “moyen”, “petit”)

Conversion d’un tableau en chaîne print @tabstr; # affiche “grand moyen petit”

Structure de contrôle : les tests

L es opérateurs de test reprennent la syntaxe du C :

!, > , < , ||, or, &&, and

Attention aux différences de traitement entre chaînes de caractères et nombre :

Nombres

 

Chaînes           Signification

 

lt                       Inférieur à

< =

 

le                       Inférieur ou égal à

 

gt                      Supérieur à

> =

 

ge                       Supérieur ou égal à

= =

 

eq                    Égal à

!=

 

ne                     Différent de

< = >

 

cmp                                                                Comparaison           renvoie -1 , 0 , ou 1 selon que le premier argument est inférieur, égal ou supérieur au second

$ a = = $ b

 

# Est-ce que $ a est numericalement égal à $ b?

 

 # Attention !! N‘utilisez jamais l’opérateur = (affectation).

$ a != $ b

 

#  Est-ce que $ a est numéricalement différent de  $ b?

$ a ne $ b

 

#  Est-ce que la chaîne $ a est différent à la chaîne $ b?

On dispose aussi des opérateur logiques et, ou et non :

                                                  ($ a && $ b)                              # Est-ce que $ a et $ b sont vrai?

                                                ($ a || $ b)                     # Est-ce que $ a ou $ b est vrai?

                                                !($ a)                               # Est-ce que $ a est faux?

Structures de contrôle : les conditions

Commandes simples

• Chaque commande doit être terminée par un point-virgule • Elle peut être éventuellement suivie d’un “modifier” : if EXPR unless EXPR while EXPR until EXPR

                             Exemple :              print “Test réussi\n” if ($ var = = 1 );

Conditions implicites

Dans une instruction Perl :

                                $ fichier = $ ARGV [0 ]  ||  “”;     # l’opérateur « || » n’évalue que ce qui est nécessaire

(l’évaluation s’arrête à la première valeur évaluée à True)

Is_ Windows_ running() && die “Please, execute me on a REAL OS… \n”; # l’opérateur « && » s’arrête à la première valeur évaluée à False Conditions explicites

if (EXPR) BL OCK # BL OCK est une séquence d’instructions délimitée par {} if (EXPR) BL OCK else BL OCK # les accolades sont obligatoires même dans le cas if (EXPR) elsif (EXPR) BL OCK … else BL OCK # d’une seule instruction

unless (EXPR) BL OCK # exécute le block si l’expression est fausse unless (EXPR) BL OCK else BL OCK

Structures de contrôle : les boucles

L a boucle foreach (pour chaque élément dans ensemble) foreach $ i (@liste)

{

                                  print $ i;               # affiche chaque élément du tableau @liste

}

Exemple : @val = (2 , 5 , 9 );

foreach $ n ( @val)

{

# $ n référence chaque valeur de @val

$ n *= 3 ;

}  # on a maintenant @val = (6 , 1 5 , 2 7 )

L a boucle for (comme en C) for(init_ expression ; test_ expression ;  incrément_ expression)

{

# corps de la boucle

}

Exemple :

for( $ i = 0 ; $ i < 1 0 ; $ i+ + )

{

print $ tab[$ i];

}

Structures de contrôle : les boucles (suite et fin)

L a boucle while, until et do… while do while (EXPR)

{

{

# à évaluer tant que l’expression est

# à évaluer tant que l’expression est vraie

# vraie et au moins une fois

} } until (EXPR) while (EXPR)

{

# à évaluer tant que l’expression est fausse

}

Ruptures de séquence : last, next et redo


while ( exp1 ) { inst1 ; if (exp2 ) {

inst2 ;

last; # sortie

}

inst3 ;

}

# reprise du last while ( exp1 ) { while ( exp1 ) {

inst1 ; # reprise du redo if ( exp2 ) {      inst1 ; inst2 ;            if ( exp2 ) { next; # ocurrence suivante inst2 ;

                                     # du while                                                            redo; # recommence le while

}         # sans évaluer exp1 à inst3 ;       # nouveau

# reprise du next                                                                  }

}                                                                                   inst3 ;

}


Tableaux associatifs % ou tables de « hachages »

Ce sont des tableaux dont l’indice n’est plus limité à un entier positif. L es éléments peuvent être indexés par des chaînes de caractères.

                              % ages = (          "Michel Dupont", 3 9 ,          # association de “Michel Dupont” à 3 9

                     "L arry Wall", 3 4 ,                           # association de “L arry Wall” à 3 4

                    "Néo", 2 7 ,

                           "Michel durand", "2 1 ans depuis deux jours" );

% tab = ( “coucou”, “ça va”, 1 2 3 .4 , 5 6 7 );

Accés aux éléments du tableau associatif

$ tab{“salut”} = “ tout va bien ?”; # association de “ tout va bien ?” à l’index “salut”

$ tab{“coucou”} .= “ ?”;

# concaténation de “ ?” à la valeur associé à l’index “coucou”

$ tab{1 2 3 .4 } + = 4 3 3 ;

# ajout de 4 3 3 à la valeur associée à l’index 1 2 3 .4

print $ tab{“hello”};

% copie_ de_ tab = % tab;

# undefined

Tableaux associatifs prédéfinis

$homedir = $ENV{‘HOME’}; # permet d’avoir accès aux variables d’environnement du processus

                               $ SIG{‘UP’} = ‘IGNORE’;                          # permet d’ignorer le traitement d’un signal

Tableaux associatifs (Suite et fin)

Opérateur keys()

                                   @clés = keys(% tableau_ associatif);  # récupére un tableau contenant toutes les clés d’indexation

Opérateur values()

                                   @valeurs = values(% tableau_ associatif);          # récupére les valeurs de chaque association

Opérateur each() while ( ($ cle, $ valeur) = each(% tab)) # permet de passer en revue les différentes associations

{

 print $ cle.“ “.$ valeur;

}

Opérateur delete()

% tab = (”coucou“ = > “ça va ?”, 1 2 3 .4 = > 5 6 7 );  # = > et synonyme de la virgule

@element = delete ($ tab{“coucou”});

# @element = (“coucou”, “ça va ?”); et % tab = (1 2 3 .4 , 5 6 7 );

                                  % tab = (% tab, “une_ cle”, “une_ valeur);           # ajout d’une association à % tab

Entrées/Sorties standards

Trois descripteurs de fichiers standards :

STDIN (entrée courante), STDOUT (sortie courante), STDERR (sortie d’erreur)

L ’impression sur la sortie standard print “bonjour \n”; # sort par défaut sur STDOUT

L ’impression sur la sortie d’erreur print STDERR “ceci est un message d\‘erreur”;

L ecture sur l’entrée standard

print “Entrez votre nom : ”;

$ nom = < STDIN> ;     # lit un mot en provenance de l’interface d’entrée (clavier par exemple) chomp($ nom);      # permet de supprimer le caractère \n ajouté lors de la saisie print “Hello $ nom\n”;

Opérateur < >

•     dans un contexte scalaire : lit les données jusqu’au prochain \n soit une ligne

•     dans un contexte de tableau : lit toutes les lignes@les_ lignes = < STDIN> ; foreach $ ligne (@les_ lignes)

                                                                    { print “> $ ligne”; }          # affiche toutes les lignes saisies en entrée

Entrées/Sorties sur fichier quelconque

Descripteur

DESCRIPTEUR en majuscule

Ouverture / Fermeture

 

open (DESCRIPTEUR,

“nom_ fichier”);

open (MONFIC,



“fichier”);                                # ouverture en lecture/écriture

open(MONFIC_ L ECTURE,

“< fichier”);                   # ouverture en lecture seule

open(MONFIC_ ECRITURE,

“> fichier”);                   # ouverture en écriture seule

open(MONFIC_ AJ OUT,

“> > fichier”);                       # ouverture en écriture à la suite

Toujours tester les opérations d’ouverture

open(MONFIC, “fichier”) || die (“Ne peut ouvrir le fichier”); close(MONFIC); # fermeture du fichier

L ecture

while($ ligne = < MONFIC> )

{

$ ligne contient une ligne du fichier

Écriture print MONFIC “L a valeur est $ var\n”;

L es fonctions

Définition sub nom_ sous_ routine { # des intructions Perl

}

                Appel                  avec le caractère &

•     sans paramètre :

&fonction_ de_ traitement ;

•     avec paramètres :

&imprimer(“hello”, “world”);

Résultat de l’appel

L e résultat de l’appel d’une fonction est la valeur de la dernière expression évaluée sub somme_ a_ b { $ a + $ b; }

                                 $ a = 2 ; $ b = 3 ; $ c = &somme_ a_ b;               # $ c vaut 5

                   Tableau de paramètres               @_

sub somme2 { $ _ [0 ] + $ _ [1 ]; }

$ c = &somme2 ($ a, $ b);

Protection des variables locales à une fonction : my() my($ var_ locale) = 1 0 ; # la variable $ var_ locale n’est connue que dans la fonction

L es expressions régulières

Une des caractèristiques les plus intéressantes de Perl, qui le rend adapté aux traitements des fichiers texte Une expression régulière est une suite de caractères suivant une certaine syntaxe qui permet de décrire le contenu d’une chaîne de caractères :

•     afin de tester si cette chaîne correspond à un motif

•     afin d‘extraire des informations

•     afin d’y effectuer des substitutions

Méta-caractères                                                                                                       Quantificateur

^ début de chaîne      * $      fin de chaîne            +

             .                       n’importe quel caractère excepté newline \n                                  ?

             |                alternative                                                                                                        {n}

             ()                  groupement et mémorisation

             []                 classe de caractère

Pour utiliser un méta-caractère, le faire précéder de \

Caractères spéciaux

             \t              tabulation                \n        newline                     \r          retour-chariot

             \w            lettre                         \W       non-lettre                \d        chiffre

Exemples

              [abc]         un des caractères                 [a-z] une des minuscules                 coucou | salut

apparaît 0 , 1 ou plusieurs fois apparaît 1 ou plusieurs fois apparaît 0 ou 1 fois apparaît exactement n fois

\s            espace          \S           non-espace

\D           non-chiffre

l’un ou l’autre

                           ^ \d$              des chiffres du début à la fin, soit un nombre

L es expressions régulières : recherche de motif

L es expressions régulières permettent de rechercher un motif dans une chaîne

Opérateur = ~ (contient) et !~ (ne contient pas) if ($ a = ~ /pat/) # vrai si la chaîne $ a contient le mot “pat” if ($ ligne = ~ /^ Données/) # vrai si la chaîne $ ligne commence par “Donnés”

Paramètres g recherche globale

i   ne pas tenir compte de la casse des caractères (pas de différence minuscule/majuscule) etc

Exemple if($ var = ~ /login/i)        # vrai si $ var contient login ou L ogin ou lOGin ou…

L es expressions régulières : substition et translation

L es expressions régulières permettent de substituer des caractères par d’autres dans une chaîne

Syntaxe :

$ var = ~ s/REGEXP/chaîne/option;

Exemple :

$ ligne = ~ s/laco1 /alpha1 /g; # indique de substituer la chaîne laco1 par alpha1 de manière globale $ texte = ~ s/paris/Paris/gi; Remarques :

Si le paramètre chaîne est omis il y a seulement suppression du motif trouvé

L es expressions régulière permettent de traduire des caractères par d’autres dans une chaîne

Syntaxe :

$ var = ~ tr/liste1 /liste2 /option;

Exemple :

                                       $ ligne = ~ tr/a-z/A-Z/;                      # passe les caractères a à z en majuscule

L es expressions régulières : mémorisation

L es expressions régulière permettent de mémoriser des suites de caractères dans un motif

Accés aux caractères précédant le motif recherché la variable spéciale $ ` (dollar quote)

Accés aux caractères composant le motif recherché la variable spéciale $ &

Accés aux caractères suivant le motif recherché la variable spéciale $ ‘ (dollar back-quote)

Éclatement et collage

Il est possible d’éclater une chaîne en sous-parties, stockées ensuite dans un tableau (éclatement). Il est possible de joindre les éléments d’un tableau dans une chaîne (collage). Opérateur split()

Exemple :

$ informations = “Premier:Ministre:Acteur:1 4 , rue Saint Honoré”;

@personne = split(/:/, $ informations);

ce qui a pour effet d’affecter à @personne :

@personne = (“Premier”, “Ministre”, “Acteur”, “1 4 , rue Saint Honoré”);

Si on a préalablement affecté $ informations à $ _ , on peut effectuer un appel plus simple : @personne = split(/:/);

On peut utiliser les ER : par exemple, si on ne connait pas le nombre de colonnes, on peut écrire : $ _ = “Dupont:J ean::Boulanger:::Avenue des champs Elysées”;

@personne = split(/:+ /); ce qui donnera

@personal = (“Dupont”, “J ean”,

                                                                                      “Boulanger”, “Avenue des champs Elysées”);

L ’opérateur join() réalise l’opération inverse.

Éclatement et collage (suite et fin)

Un paragraphe peut être séparé en phrase, une phrase en mots, et un mot en caractères.

                                         @caracteres = split(//, $ mot);                                      # séparation en caractères

@mots = split(/ /, $ phrase);      # séparation suivant les espaces @phrases = split(/\./, $ paragraphe);         # séparation suivant les points

L es éléments d’un tableau peuvent être réunis au sein d’une chaîne de caractères

$ chaine = join (“ “, @tableau);

Gestion de Processus

system() permet d’exécuter une ligne de commande system(“date”); system(“date > ficdate”); system(“more /etc/passwd”);

back-quote ` ` $ date = ` date` ; foreach $ fichier (` ls *.back` ) {

print “fichier backup : $ fichier”; }

Pipeline associe la sortie d’un processus à l’entrée d’un autre

open (FINGER, “ finger |”); @finger = < FINGER> ;

# lecture du pipe

open (L PR, “| lpr”); print L PR $ rapport;

# écriture du pipe

Fork scission d’un processus en deux processus distincts if (fork) { # je suis le fils

} else { # je suis le pere

}

Utilisation du réseau : conception d’un client

Obtention de l’adresse Internet d’une machine

$ targethost = “”;

$ internet_ addresse = gethostbyname($ target_ host) or die "hote absent: $ target_ host";

                                  $ internet_ addresse = pack('C4 ', 1 9 3 , 5 0 , 1 8 5 , 1 );     # adresse donnée sous forme numérique

Configuration d‘une socket de communication

                                    $ protocole = getprotobyname('tcp');                 # sélection du protocole TCP

$ destination = pack('S n a4 x8 ', AF_ INET, $ target_ port, $ internet_ addresse); # package final de # toutes les informations nécessaires à la connexion

socket(SOCK, AF_ INET, SOCK_ STREAM, $ protocole) or die "socket: $ !"; # création du socket connect(SOCK, $ destination) or die "connect: $ !"; # tentative de connection setsockopt(SOCK, SOL _ SOCKET, SO_ REUSEADDR, 1 ); # configuration relative au système autoflush SOCK, 1 ; # on ne désire pas de buffer sur la socket

foreach $ ligne (@lignes)

{

print SOCK $ ligne;                # transmission des données en direction du serveur

}

Utilisation du réseau : conception d’un serveur

Configuration du port de communication

$ port_ comm_ serveur = 8 0 8 0 ; # port de communication n° 8 0 8 0 $ protocole = getprotobyname('tcp'); # sélection du protocole TCP socket(SERV EUR, AF_ INET, SOCK_ STREAM, $ protocole) || die "Ouverture socket: $ !"; setsockopt(SERV EUR, SOL _ SOCKET, SO_ REUSEADDR,1 )) || die "Configuration socket: $ !";

# configuration relative au système

bind(SERV EUR, sockaddr_ in($ port_ comm_ serveur, INADDR_ ANY)) || die "Accrochage socket: $ !";

# accrochage de la socket au numéro de port sélectionné

                                     listen(SERV EUR, SOMAXCONN) || die "Ecoute socket: $ !";  # configuration de l’écoute

                                      while($ socket_ courante = accept(CL IENT, SERV EUR))                      # attente de connection d’un client

{

    ($ port_ comm_ client, $ iaddr) = sockaddr_ in($ socket_ courante); # infos relatives au client

$ pid = fork;                             # Création d'un processus enfant

    if ($ pid) { # le père attend que l’enfant est terminé de gérer la requête         wait; close CL IENT;

    }     else

    {

        open STDIN, "< &CL IENT"; # accrochage des E/S standards de l’enfant sur la socket         open STDOUT, "> &CL IENT";

exec "GestionRequete" || die "exec: $ !";                                  # lancement de “GestionRequete” avec STDIN et

}                                                                                       # STDOUT redirigés vers la socket

}



248