SELFHTML/Aides à la navigation CGI/Perl Éléments de langage Perl| SELFHTML/Aides à la navigation CGI/Perl Éléments de langage Perl |
Les expressions régulières sont des modèles de recherche précisément définis. À l'aide de ces modèles de recherche, vous pouvez par exemple parcourir le contenu de variables et en extraire ou en remplacer des contenus déterminés. Ainsi vous pouvez à l'aide d'expressions régulières à la lecture de fichiers (par exemple d'un fichier avec les inscriptions d'un livre des visites) au vu des instructions d'après lesquelles le fichier est construit, lire les différentes inscriptions dans l'ordre et les envoyer sous forme de code HTML au navigateur appelant. . Et les expressions régulières sont aussi un moyen puissant pour rechercher des expressions de recherche complexes dans des bases de données importantes.
Les expressions régulières sont sans doute très inhabituelles pour les débutants qui ne viennent pas du monde Unix, et c'est la raison principale pour laquelle on trouve dans certains scripts Perl des chaînes de caractères assez étranges qu'on pourrait croire cryptées. En revanche, celui qui a l'habitude de la commande Unix grep, comprendra immédiatement avec les expressions régulières en Perl.
 
|
Les deux petits exemples d'introduction doivent montrer dans quelles situations typiques les expressions régulières sont mises en œuvre.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title>\n";
print "</head><body>\n";
my @localites = ("Madrid","Londres","Milan","Paris","Rome","Marseille");
foreach(@localites) {
if( $_ =~ /^M/ ) {
print "$_ commence par M <br>\n";
}
}
print "</body></html>\n";
|
L'exemple déclare un 
Array nommé @localites avec six noms de villes. Ensuite il parcourt les éléments du tableau dans l'ordre avec une boucle foreach. Dans le bloc de la boucle, il est vérifié si le nom de la ville dans le parcours actuel de la boucle commence par M. Pour cela, la variable prédéfinie $_, dans laquelle est contenue dans une boucle foreach la valeur actuelle, est liée à une expression régulière avec l'opérateur =~ . L'opérateur =~ est spécialement conçu pour les expressions régulières. L'expression régulière elle-même figure par défaut entre des barres obliques. Entre ces barres obliques est défini un modèle de recherche. Le modèle de recherche de l'exemple ^M signifie ni plus ni moins que "commence par M ".
Toute l'instruction if( $_ =~ /^M/ ) est donc à lire comme: Si la condition est remplie qu la valeur du contenu actuel de la boucle commence par M ...
À vrai dire vous pouvez également omettre la chaîne de caractères $_ =~, étant donné que l'expression régulière est alors automatiquement reliée à la variable prédéfinie $_. Pour une meilleure compréhension, la notation détaillée a été choisie ici.
L'exemple sort dans ce cas le contenu de la boucle. À la fin seront donc sorties les trois villes du tableau @localites qui commencent par M.
L'exemple suivant est un peu plus exigeant:
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title>\n";
print "</head><body>\n";
my $ligne = "{link:http://actuel.fr.selfhtml.org/{pages Selfhtml}}";
$ligne =~ /\{link:(.*)\{(.*)\}\}/;
my $lien = $1;
my $$texte_lien = $2;
print "<a href=\"$lien\">$texte_lien</a>";
print "</body></html>\n";
|
Dans ce script, il y a une scalaire nommée $ligne, qui sauvegarde comme valeur une chaîne de caractères qui a visiblement une certaine structure. Elle est placée entre parenthèses accolades. D'abord est noté link: suivi d'une URI, puis à nouveau entre parenthèses accolades, un texte. Cette structure avec les parenthèses accolades est inventée librement. Cependant presque toute l'informatique consiste à sauvegarder des données d'après des structures et conventions quelconques que l'ordinateur peut reconnaître. Les expressions régulières sont appropriées pour filtrer quelque chose de bien déterminé de ces structures. Dans l'exemple, le script filtre à l'aide d'une expression régulière, dans la chaîne de caractères l'URI et le texte dans les deuxièmes parenthèses accolades intérieures et fabrique avec ces deux valeurs partielles un lien HTML qui est sorti à la fin dans le navigateur avec print.
Avec l'instruction $ligne =~ /\{link:(.*)\{(.*)\}\}/; l'expression régulière placée entre les deux barres obliques, est appliquée sur la valeur de la scalaire $ligne . Pour clarifier un peu cette accumulation de signes épouvantable, abordons déjà les barres obliques inverses \ qui y sont mentionnées. Celles-ci servent à masquer le signe qui suit chacune d'entre elles et veulent dire simplement: le signe qui suit doit être traité comme signe tel qu'il figure. Donc \{ signifie simplement par exemple: le signe qui suit { ne doit pas être interprété autrement que ce qu'il est.
Ce que l'expression régulière doit négliger doit donc commencer ensuite avec la chaîne de caractères {link:. Ensuite tout peut arriver. C'est ce qui est exprimé par .* Tôt ou tard doit ensuite se trouver une parenthèse accolade d'ouverture { dans la valeur recherchée. Derrière à nouveau, tout peut arriver, donc .*, et à la fin doivent être placées à nouveau deux parenthèses accolades de fermeture. Ainsi est donc définie un "modèle" à l'aide de l'expression régulière, qui convient à la valeur dans laquelle on recherche tout en laissant la possibilité de modifier certaines choses.
Ici également a été choisie une simplification pour une meilleure compréhension. L'expression partielle .* fonctionne certes dans cet exemple, peut toutefois dans des cas moins propices reconnaître trop de choses en raison de son abondance.
Les deux passages variables donc ceux qui sont marqués par .* sont inclus dans l'exemple entre parenthèses. Les parenthèses indiquent le souhait que Perl se note ce qui y figure. Ainsi dans l'exemple, deux passages variables sont ils notés de cette façon:
{link:http://actuel.fr.selfhtml.org/{pages Selfhtml}}
Les passages représentés en caractères gras sont maintenant sauvegardés dans les deux paires de parenthèses.
Pour parvenir à ces valeurs sauvegardées, Perl dispose de variables prédéfinies nommées $1, $2, $3 etc... Dans $1 est sauvegardé le contenu de la première parenthèse de l'expression régulière, dans $2 le contenu de la deuxième parenthèse. Le script en exemple déclare deux scalaires nommées $lien et $texte_lien, auxquelles il affecte les deux valeurs sauvegardées dans les parenthèses.
Le reste coule de source: dans une instruction print, qui sort le code pour une lien HTML, les deux scalaires $lien et $texte_lien sont insérées aux endroits où leurs valeurs doivent se trouver.
Un domaine d'application important pour les expressions régulières est aussi les actions pour Chercher et remplacer avec des expressions régulières. Les expressions régulières peuvent en outre être placées dans quelques fonctions Perl comme paramètre transmis, par exemple dans la fonction split.
|
|
Dans une chaîne de caractères, vous pouvez
Ces expressions ne sont pas tant appropriées pour des modèles de recherche que pour s'assurer si dans une valeur certains signes sont placés, par exemple des signes non autorisés.
|
Quand vous voulez chercher un signe déterminé avec une expression régulière, vous devez mettre l'expression recherchée entre des délimiteurs (ici les barres obliques) comme dans les exemples (1.) et (12.-15.). Quand le signe recherché est un signe réservé à l'intérieur d'expressions régulières, comme par exemple un +,, vous devez le masquer avec une barre oblique inversée (\+).Les signes réservés sont en tous cas +?.*^$()[]{}|\.
Quand vous ne voulez en réalité que vérifier l'existence d'un signe ou d'une chaîne de caractères fixe, il vaut mieux choisir la fonction index .
Pour les expressions régulières, sont plus intéressants les cas dans lesquels vous voulez vérifier si un signe est placé et doit convenir à différentes possibilités ou doit explicitement ne pas convenir, comme dans les exemples (2.-11.) et (16.-19.). Pour cela existent dans les expressions régulières ce qu'on appelle les classes de caractères. Une classe de caractères est notée par principe entre crochets [...], comme dans les exemples (2.-4.), (7.-9.) et (18.-19.). Une classe de caractères convient toujours exactement à un signe. À l'intérieur de cette classe, vous pouvez maintenant énumérer les différents caractères de cette classe en les notant à la suite l'un de l'autre. Les signes réservés doivent ici aussi être masqués explicitement avec une barre oblique inversée, comme dans l'exemple (8.). Quand vous avez une plage de signes plus importante qui doit convenir, vous pouvez mentionner celle-ci en notant le premier signe de la plage suivi du signe moins comme trait d'union - et ensuite le dernier signe de la plage comme dans les exemples (3.), (4.), (9.) et (19.). Si vous pensez au trait d'union en tant que caractère proprement-dit, notez le au début de la classe de caractères comme dans l'exemple (7.).
Pour certaines classes de caractères revenant souvent, existent des abréviations. Ainsi [0-9] correspond à \d et à [ \r\n\t\f] correspond \s. À [a-zA-Z0-9_] correspond en général l'abréviation \w. Vous pouvez également utiliser ces abréviations à l'intérieur de classes de caractères comme dans l'exemple (7.).
Vous pouvez nier des classes de caractères pour établir qu'elles ne doivent pas convenir à un signe déterminé, comme dans les exemples (18.) et (19.). Pour ce faire, notez directement après le crochet d'ouverture [ l'accent circonflexe ^. Veillez qu'il faut alors que dans la chaîne de caractères où s'effectue la recherche, au moins un caractère pour lequel l'expression régulière ne convient pas bien qu'aucune lettre ne figure dans la chaîne de caractères. Si par exemple vous appliquez l'exemple (19.) à une chaîne de caractères vide, vous obtiendrez pour résultat que l'expression régulière ne convient pas. Pour nier les abréviations de classes de caractères comme par exemple \s ou bien \d, modifiez simplement le "nom" de l'abréviation en majuscule, à savoir \S ou \D.
|
|
Vous pouvez
Ce genre d'expressions régulières est conçu pour rechercher par exemple dans une valeur l'occurrence d'un certain mot, d'une chaîne de caractères partielle au choix ou d'un modèle.
|
Quand vous voulez rechercher une certaine chaîne de caractères dans une expression régulière, notez simplement la chaîne de caractères entre les deux barres obliques de l'expression régulière comme dans l'exemple (1.). Néanmoins s'applique ici aussi la même chose que pour les Expressions régulières pour signes distincts: Quand vous voulez rechercher une chaîne de caractères fixe, il vaut mieux choisir la fonction index.
Les expressions régulières sont pour ainsi dire un langage distinct qui est représenté par des mots reliés par des règles grammaticales. La liaison se fait par des opérateurs. La raison pour laquelle les expressions régulières paraissent si compliquées est la forte compression de la notation.
Un mot dans le langage des expressions régulières est nommé Atome. Les atomes représentent toujours exactement un signe cherché, par exemple a, [abc], . ou \[. La classe de caractères [abc] représente un signe, qui peut être 'a', 'b' ou 'c'. Le point . est une abréviation pour une classe de caractères tout à fait spéciale qui contient tous les signes à l'exception du passage à la ligne. Il correspond donc dans la ligne d'invite DOS à ?. La construction \[ représente un crochet qu'il faut cependant masquer par la barre oblique inversée, quand elle ne doit pas être interprétée comme caractère de contrôle.
Pour former un modèle de recherche cohérent avec des atomes, notez simplement les atomes à la suite sans espace.
Vous pouvez marquer les répétitions de caractères avec des opérateurs de répétition.
Le point d'interrogation ? signifie dans une expression régulière: le signe avant le point d'interrogation ou non. voyez à ce sujet l'exemple (2.).
Le signe plus + signifie: une ou plusieurs répétitions du signe placé avant le signe plus. voyez à ce sujet l'exemple (4.).
Le signe étoile * signifie: pas de, une ou plusieurs répétitions du signe placé avant l'étoile. voyez à ce sujet l'exemple (5.).
Si vous notez un point (qui remplace un signe quelconque) avant le signe plus + ou *, vous obtenez un joker qui correspond à l'astérisque * dans l'univers DOS/Windows, par exemple pour les noms de fichiers. voyez à ce sujet les exemples (6.) à (9.).
Les parenthèses accolades avec un ou deux nombres n qui y sont placés {n} signifient n répétitions du signe placé avant les parenthèses accolades à l'endroit concerné - voyez à ce sujet les exemples (10.) à (12.). Ici, vous pouvez également noter le point devant les parenthèses accolades. Dans ce cas, la mention dans les parenthèses accolades signifie: autant de signes quelconques que mentionné - voyez à ce sujet l'exemple (12.)
Vous pouvez rechercher des chaînes de caractères qui ne seront trouvées que si elles se trouvent au début ou à la fin d'un mot. Même l'inverse est possible: Vous pouvez rechercher des chaînes de caractères qui ne seront trouvées que si elles ne se trouvent pas au début ou pas à la fin d'un mot.
Avec \b avant une chaîne de caractères, la chaîne de caractères ne sera trouvée que si elle se trouve au début d'un mot.
Avec \b après une chaîne de caractères, la chaîne de caractères ne sera trouvée que si elle se trouve à la fin d'un mot.
Avec \B avant une chaîne de caractères, la chaîne de caractères ne sera trouvée que si elle ne se trouve pas au début d'un mot.
Avec \B après une chaîne de caractères, la chaîne de caractères ne sera trouvée que si elle ne se trouve pas à la fin d'un mot.
Concernant ces possibilités voyez les exemples (13.) à (16.).
Pour être précis, \b définit la limite entre \w et \W (ou le début de la chaîne de caractères, ou la fin).
Vous pouvez rechercher des chaînes de caractères qui ne seront trouvées que si elles se trouvent au début ou à la fin d'une ligne dans le passage à parcourir. Ce qui est avant tout intéressant en relation avec des lignes dans des fichiers texte.
Avec l'accent circonflexe ^ au début de l'expression recherchée, la chaîne de caractères ne sera trouvée que si elle est au début d'une ligne.
Avec le signe Dollar $ à la fin de l'expression recherchée, la chaîne de caractères ne sera trouvée que si elle est à la fin du passage.
Concernant les possibilités voyez les exemples (17.) bis (19.).
Vous pouvez également employer des variables à l'intérieur d'expressions régulières. Par ce moyen, vous pouvez utiliser des données dynamiques comme critères de recherche. En relation avec CGI vous pourriez par exemple prendre comme critère de recherche l'entrée de l'utilisateur dans un champ de formulaire. Voyez à ce sujet l'exemple (20.).
|
|
Étant donné qu'il existe pour les expressions régulières quelques signes ayant une signification particulière, vous devez masquer ces signes quand vous l'employez non pas dans ce sens particulier mais dans sa signification littérale normale, donc une barre verticale en tant que barre verticale ou un point en tant que point. Le signe servant à masquer est dans tous les cas la barre oblique inversée.
|
|
|
Normalement toutes les expressions régulières qui contiennent des expressions avec des caractères de remplacement comme .*, sont très "abondantes". Elles récoltent autant de signes qu'il est possible. Il existe cependant un moyen de forcer de telles expressions à plus de modération.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><head><title>Sortie du test</title>\n"; print "</head><body>\n"; my $ligne_HTML = "<html><head><title>Sortie du test</title></head><body><h1>&Titre</h1></body></html>"; $ligne_HTML =~ /(^<.+>)/; my $abondant = $1; $ligne_HTML =~ /(^<.+?>)/; my $modere = $1; $abondant =~ s/</</g; # seulement pour sortie HTML $abondant =~ s/>/>/g; # seulement pour sortie HTML $modere =~ s/</</g; # seulement pour sortie HTML $modere =~ s/>/>/g; # seulement pour sortie HTML print "<p><b>version abondante:</b> <tt>$abondant</tt></p>"; print "<p><b>version modérée:</b> <tt>$modere</tt></p>"; print "</body></html>\n"; |
Le scripte en exemple prouve l'abondance de l'expression régulière et montre aussi comment celle-ci peut être empêchée. Une scalaire nommée $ligne_HTML est déclarée et reçoit comme valeur initiale le code d'un entête complet de fichier HTML. Ensuite cette scalaire est évaluée avec une expression régulière, qui y recherche un modèle /(^<.+>)/. Tout le modèle de recherche est placé entre parenthèses parce qu'ensuite doit être sorti ce qui a été trouvé. Le résultat de la recherche est sauvegardé dans la scalaire $abondant. Ensuite la procédure est répétée. Cette fois, l'expression régulière ne diffère que légèrement: elle contient encore derrière le signe plus un point d'interrogation.
Les deux résultats de la recherche sont ensuite encore préparés pour la sortie HTML en remplaçant les parenthèses pointues conformément à HTML (voyez aussi à ce sujet Chercher et remplacer avec des expressions régulières).
La sortie de $abondant donne:
<html><head><title>Sortie du test</title></head><body><h1>Überschrift</h1></body></html>
La sortie de $modere donne par contre:
<html>
L'expression avec caractères de remplacement .+, qui doit "tout" "récolter" jusqu'au signe >, ne s'arrête pas à vrai dire au > suivant, mais seulement au tout dernier. En ajoutant le point d'interrogation, donc par l'extension à .+?, le modèle se limite à trouver le signe > suivant.
|
|
Vous pouvez noter plusieurs critères de recherche. Toutes les chaînes de caractères, dans lesquelles se trouve au moins un des critères de recherche, seront alors trouvées.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); print "Content-type: text/html\n\n"; print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n"; print "<html><head><title>Sortie du test</title>\n"; print "</head><body>\n"; my $texte = "café sans lait"; print "peu importe que ce soit avec ou sans<br>\n" if ($texte =~ /avec|sans/); $texte = "café avec lait"; print "mais je l'ai dit: peu importe que ce soit avec ou sans<br>\n" if ($texte =~ /avec|sans/); print "</body></html>\n"; |
Le script en exemple déclare une scalaire $texte avec la valeur initiale café sans lait. En fonction du succès de l'expression régulière /avec|sans/, qui est appliquée sur cette scalaire, est sorti dans le navigateur appelant: peu importe que ce soit avec ou sans. La barre verticale | divise l'expression régulière en deux alternatives pour lesquelles suffit que l'une d'entre elles soit trouvée. Étant donné que c'est le cas, la phrase est sortie dans le navigateur. Pour le contrôle, le texte est ensuite modifié en café avec lait. La même expression régulière appliquée ensuite est à nouveau fructueuse, et la sortie mais je l'ai dit: peu importe que ce soit avec ou sans a lieu.
|
|
À l'aide de la mise entre parenthèses des différentes parties d'une expression régulière vous pouvez sauvegarder des modèles partiels et les réutiliser à un autre endroit.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Sortie du test</title>\n";
print "</head><body>\n";
my $CTIME = localtime(time);
$CTIME =~ /^([A-Za-z]*?)\s*([A-Za-z]*?)\s*(\d*?)\s*(\d*?):(\d*?):(\d*)\s*(\d*)$/;
my $jour = $1;
my $mois = $2;
my $jour_mois = $3;
my $heures = $4;
my $minutes = $5;
my $secondes = $6;
my $an = $7;
my %jours = (Mon => "Lundi", Tue => "Mardi", Wed => "Mercredi",
Thu => "Jeudi", Fri => "Vendredi", Sat => "Samedi", Sun => "Dimanche");
my %mois = (Jan => "01", Feb => "02", Mar => "03", Apr => "04", May => "05", Jun => "06",
Jul => "07", Aug => "08", Sep => "09", Oct => "10", Nov => "11", Dec => "12");
print "<b>Aujourd'hui nous sommes $jours{$jour}, le $jour_mois/$mois{$mois}/$an, il est $heures:$minutes heures</b>\n";
print "</body></html>\n";
|
L'exemple appelle la fonction Perl localtime avec la valeur retournée par la fonction time et sauvegarde la valeur renvoyée par localtime dans la scalaire $CTIME. Y est ensuite sauvegardée une chaîne de caractères, construite comme suit:
Sun Jun 17 21:37:40 2001
Dans l'instruction suivante $CTIME est évalué avec une longue expression régulière de recherche. L'expression régulière tente de recenser l'ensemble du modèle typique de la chaîne de caractères de la date et de l'heure. Les données utiles, à savoir le jour de la semaine, le nom du mois, le jour du mois, les heures, les minutes, les secondes et l'année sont mises entre parenthèses dans l'expression régulière. Perl repère chaque contenu de ces parenthèses et le tient à disposition dans les variables prédéfinies en Perl $1, $2, $3 etc... Les scalaires déclarées ensuite se prennent les valeurs entre parenthèses quand les variables prédéfinies correspondantes leur sont affectées.
Les deux hashes %jours et %mois sont utilisés dans le but d'avoir un format de la date et de l'heure en français. Le script sort à la fin quelque chose qui ressemble à:
Aujourd'hui nous sommes Dimanche, le 17/06/2001, il est 21:37 heures.
|
|
Les signes spéciaux dans les expressions régulières sont évaluées dans un certain ordre de priorité par l'interpréteur Perl.
() (parenthèses)
+ * ? {#,#} (opérateurs de répétition)
abc ^ $ \b \B (caractères/chaînes de caractères, début et fin de ligne, début et fin de mot)
| (alternatives)
Par cette prééminence, toute expression régulière peut être évaluée de façon univoque. Quand vous désirez toutefois faire une autre évaluation que celle fixée par l'ordre de priorité dans une expression vous pouvez poser des parenthèses dans l'expression pour imposer une évaluation différente.
/a|bc|d/ # trouve 'a' ou bien 'bc' ou 'd' /(a|b)(c|d)/ # trouve 'ac' ou bien 'ad' ou 'bc' ou 'bd' |
D'après l'ordre de priorité, les signes ou les chaînes de caractères ont priorité sur les signes de séparation pour alternatives. À l'aide de parenthèses, vous pouvez imposer une autre évaluation (voir exemple).
Quand vous désirez utiliser les parenthèses pour modifier l'évaluation, sans vouloir cependant repérer des expressions partielles correspondantes, vous pouvez également utiliser les parenthèses qui groupent seulement. Pour ce faire est notée directement la parenthèses d'ouverture la suite de caractères ?:, ce qui donnerait dans l'exemple (?:a|b)(?:c|d).
|
|
Derrière le caractère délimitant la fin d'une expression régulière (en principe: la barre oblique) vous pouvez encore noter une ou plusieurs lettres - ce qu'on appelle drapeaux (flags). Par ce biais vous pouvez avoir une influence supplémentaire sur la conduite de la recherche. Avec une notation telle que /vers/g vous recherchez par exemple globalement une occurrence de vers, et avec /vers/gim vous recherchez la chaîne de caractères vers globalement, qu'elle soit en minuscules ou en majuscules, et la chaîne de caractères peut également comprendre plusieurs lignes. Vous pouvez donc combiner les drapeaux à votre gré. Le tableau suivant dresse la liste des drapeaux possibles.
|
|
|
Les expressions régulières sont le moyen avec lequel en Perl, quelque chose est recherché et remplacé dans les chaînes de caractères.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); print "Content-type: text/plain\n\n"; my $texte = "Julien parcourt le Morvan dans un taxi hors d'usage 1234567890"; $texte =~ s/[a-z]| //gi; print "$texte\n"; |
Le schéma pour tous les processus de recherche-remplacement en Perl est:
$chaine_de_caracteres =~ s/modele_recherche/chaine_caracteres_remplacement/[drapeaux]
$chaine_de_caracteres est une scalaire dans laquelle est sauvegardée une chaîne de caractères, comme par exemple $texte dans l'exemple 1 ci-dessus. Cette scalaire est associée au remplacement par l'opérateur =~, c'est à dire que le processus de recherche-remplacement s'applique au contenu de la scalaire. Notez derrière le remplacement. Il est introduit par un s minuscule. Après le s notez le premier signe délimiteur (par défaut une barre oblique), et ensuite le modèle de recherche qui se termine avec le deuxième signe délimiteur. Suivent ensuite le signe ou la chaîne de caractères par lesquelles les occurrences doivent être remplacées, et qui se terminent par le troisième signe délimiteur. Si cela s'avère nécessaire, notez encore derrière le troisième signe délimiteur des drapeaux pour le processus de recherche-remplacement. Dans l'exemple, les drapeaux suivants ont été employés:
g cherche/remplace toutes les occurrences (sinon seule la première occurrence est remplacée)
i cherche/remplace les lettres peu importe si elles sont en minuscules ou en majuscules (sinon la casse est différenciée).
Dans l'exemple ci-dessus toutes les lettres (majuscules et minuscules) sont ôtées de la scalaire $texte ainsi que tous les espaces. Il ne reste donc plus ensuite que les chiffres à la fin. Le résultat est sorti pour contrôle.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); print "Content-type: text/plain\n\n"; my $texte = "Être ou ne pas être là est la question, proférait un célèbre britannique qui a conçu de nombreuses pièces pour le théâtre"; $texte =~ s/Ê/Ê/g; $texte =~ s/ê/ê/g; $texte =~ s/à/à/g; $texte =~ s/é/é/g; $texte =~ s/è/è/g; $texte =~ s/ù/ù/g; $texte =~ s/â/â/g; $texte =~ s/ç/ç/g; print "$texte\n"; |
Dans cet exemple tous les caractères avec accent français et c cédille dans $texte sont remplacés par leur transcription conforme à HTML. Le résultat est sorti pour contrôle.
|
|
Pour des travaux moins "importants" que la recherche-remplacement ou le comptage de différents caractères, il existe une possibilité de travailler en Perl sans expression régulière. Pour cela existe une syntaxe spéciale, l'opérateur de translittération tr.
#!/usr/bin/perl -w use strict; use CGI::Carp qw(fatalsToBrowser); print "Content-type: text/plain\n\n"; my $principe = "abc"; $principe =~ tr/ac/xy/; print "Principe = $principe\n"; my $chinois = "Roulette chinoise rigolotte"; $chinois =~ tr/Rr/Ll/; print "chinois = $chinois\n"; my $hurlement = "COMMENT CELA MARCHE EN PERL?"; $hurlement =~ tr/A-Z/a-z/; print "hurlement = $hurlement\n"; my $nom_variable = "Ségémâlèxômîlù"; $nom_variable =~ tr/A-Za-z_0-9/_/c; print "Nom de variable = $nom_variable\n"; my $pas_net = "une phrase avec des espaces superflus"; $pas_net =~ tr/ //s; print "pas net = $pas_net\n"; my $phrase_z = "Vous auriez vu Zorro zébrer de sa lame l'azur d'un zigzag en zézayant"; my $compteur_z = ($phrase_z =~ tr/Ww//); print "Il y a dans phrase_z $compteur_z occurrences de Z/z!\n"; my $mot_huit_bits = "égérie"; $mot_huit_bits =~ tr/\200-\377/\000-\177/; print "mot huit bits = $mot_huit_bits\n"; my $phrase_cryptee = "tous sont des gobes-mouches!"; $phrase_cryptee =~ tr/a-zA-Z/n-za-mN-ZA-M/; print "phrase cryptée = $phrase_cryptee\n"; |
Une translittération consiste à remplacer des signes distincts par d'autres signes. Le schéma pour une translittération en Perl est:
$chaine_caracteres =~ tr/modele_recherche/modele_remplacement/[options]
Ici, ni le modèle de recherche ni le modèle de remplacement ne sont des chaînes de caractères mais seulement des signes distincts ou des plages de signes. Les modèles sont pour ainsi dire deux listes de signes. Quand dans $chaine_caractères un signe qui figure dans la liste de recherche est trouvé, il est remplacé par le signe de la liste de remplacement qui figure à la même position.
Tous les exemples du script ci-dessus sont construits de la même façon. Une scalaire avec une valeur "intéressante" est déclarée. Puis une translittération est appliquée à cette valeur et finalement, le résultat est sorti.
Dans le cas de $principe le principe de la translittération est illustré: dans l'exemple, a est remplacé par x et c par y. La sortie donne pour cette raison:
Principe = xby
Dans le cas de $chinois les lettres R et r sont remplacées par L et l. La sortie donne pour cette raison:
chinois = Loulette chinoise ligolotte
Dans le cas de $hurlement toutes les majuscules sont remplacées par les minuscules correspondantes (correspond à peu près à la fonction lc). La sortie donne pour cette raison:
hurlement = comment cela marche en perl?
Dans le cas de $nom_variable tous les signes qui ne sont pas ni une lettre de A à Z ou de a à z ni un chiffre ni un tiret de soulignement, sont remplacés par le tiret de soulignement _. La sortie donne pour cette raison:
Nom de variable = S_g_m_l_x_m_l_
Dans le cas de $pas_net tous les espaces doubles ou multiples sont ôtés. La sortie donne pour cette raison:
pas net = une phrase avec des espaces superflus
Dans le cas de $phrase_z la valeur retournée par une translittération est mise à profit. Il ne se passe rien avec la scalaire $phrase_z, mais la valeur retournée trouve combien de lettres Z ou z sont placées dans la phrase. La sortie donne pour cette raison:
Il y a dans phrase_z 8 occurrences de Z/z!
Dans le cas de $mot_huit_bits tous les signes avec des valeurs de signes comprises entre 128 et 255 sont convertis en signes avec les valeurs correspondantes comprises entre 0 et 127. La sortie donne pour cette raison:
mot_huit_bits = }g}rie
Dans le cas de $phrase_cryptee tous les signes de la première partie de l'alphabet sont transformés en signes de la deuxième partie et inversement (ils sont pour ainsi dire inversé de 13 valeurs de signes). La sortie donne:
phrase cryptée = gbhf fbag qrf tborf:zbhpurf!
(le principe de cryptage est appliqué quelquefois dans les groupes de nouvelles pour dire des choses qui ne doivent pas être comprises par tous)
|
| |
 |
Sous-programmes
|
 |
Opérateurs
|
| SELFHTML/Aides à la navigation CGI/Perl Éléments de langage Perl |
© 2001 Stefan Münz / © 2003 Traduction 
Serge François, 13405@free.fr selfhtml@fr.selfhtml.org