^
recherche depuis le début de la chaîne (ou
de
la ligne avec /m).
$
recherche à la fin de la chaîne (ou de la
ligne
avec /m).
\b
recherche à la terminaison du mot (entre \w et
\W)
\B
ne recherche pas à la terminaison du mot.
\A
recherche depuis le début de la chaîne.
\Z
recherche à la fin de la chaîne.
\G
recherche où le précédent m//g a abandonné.
(?=
...)
correspond si le moteur trouve ... ensuite.
(?!
...)
correspond si le moteur ne trouve pas ... ensuite.
Littéraux
Alphanumériques:
---------------------------
\n
saut de ligne
\r
retour chariot.
\t
tabulation horizontale.
\f
saut de page.
\b
Backspace.
\d
un chiffre, identique à [0-9].
\D
un non-numérique
\w
un alphanumérique dans un mot identique à
[0-9a-z_A-Z]
\W
un caractère ailleurs que dans un mot
\s
un espace, identique à [ \t \n \r \f]
\S
un caractère autre qu'espace
\a
Alerte (bell).
\e
échappement en caractère
\033
échappement
en Octal
\x7f
DEL
en hexadécimal.
\cC
contrôle-C
\u
force le caractère suivant en majuscule.
\l
force le caractère suivant en minuscule.
\U
force tous les caractères suivant en majuscule.
\L
force tous les caractère suivant en minuscule.
\Q
Préfixe par antislash tout les caractères
alphanumériques.
\E
Fin de \U,
\L
et
\Q.
a savoir
:
-----
'
apostrophe simple: pas de d'interpolation
"
apostrophe double: interpolation
(\'
et
\\
permettent
d'inclure un antislash dans une chaîne en apostrophe
.
Et
en regle generale permet d'oter toute ambiguité avec les
caractères
spéciaux car le signe \ devant un caractère
spécial
le rend commun, c'est à dire qu'il sera désormais qu'un
caractère
littéral, il ne representera rien plus que lui même.
exp:
pour passer une balise sortante </TD> dans une expression
régulière
on écrira /<\/TD\>/ ou /<\/\w{2}\>/.
<>
permet
de lire une ligne dans l'entrée standard, le resultat par defaut
ce trouve dans$_
qui
est l'espace de recherche du motif par defaut au même titre que
la
liste @_
est la variable liste contenant tout les
$_
.
Délimiteurs:
------------
courrant:
générique:
signification: interpolation:
''
q//
constante non
""
qq//
constante oui
``
qx//
commande oui
()
qw//
liste de mots non
//
m//
rech de motif oui
s///
s///
substitution oui
y///
tr///
traduction non
les
Modificateur:
------------------
Ou options de motif
c
Ne
pas réinitialiser la position de recherche lors d'un
échec
avec /g.
g
Recherche
globale, traiter toutes les occurrences.
i
permet de rechercher sans tenir compte de la casse
(maj,
min)
m
traite la chaîne comme des lignes multiples
o
compilation
du motif uniquement la première fois.
s
traite la chaîne comme une seule ligne
x
ignore les espace et commantaires
liste
des meta caractères:
---------------------------
\ | ( ) [ ] { } ^ $ * +
? .
Les
quantificateurs:
--------------------
En
général
entre accolades, avec deux chiffres qui signifie minimum et maximum:
exemple:
\w{1,} idem que \w+ qui cherche un ou plusieurs caractères
jusqu'a l'infini .
+
est l'équivalant de
{1,} (1 ou plus
d'élément qui précéde).
*
est l'équivalant de {
0,}
(0 ou plus d'élément qui précéde).
?
est l'équivalant de
{0,1}
(0 ou 1 élément qui précéde).
/ ca{2} / correspond à caa et non à caca, pour ça il faut /( ca){2} /
les ancres:
------------
Les ancres permettent
de restreindre l'espace de recherche, on les appelles aussi contreinte,
règles ou assertions.
\b
correspondà une limite de mot, qui est
défini
comme "rien" entre un caractère de mot
(\w
)
et un non-mot (
\W)
,
dans le désordre. (Les caractères qui n'existent pas de
par
et d'autre de la chaîne sont appelés des caractères
de non-mot):
exemple:
/\balain\b/
qui
correspond à «alain le gredin
»
mais pas à «galain
».
^
correspond
à rien au debut de la chaîne
$
correspond
à rien à la fin.
les
Opérateurs:
---------------
Un opérateur
est un caractère spécial qui produit une autre valeur (le
résultat) à partir de deux ou plusieurs autres valeur
(opérandes).
pour les nombres:
+
pour additionner. ex: $b = 2+3; =>
$b ==
5
-
pour soustraire ex: $c = 10-$b; =>
$c ==
$b
*
pour multiplier ex: $d = 2.5*2; =>
$d ==
$b
/
pour diviser ex: $e
=
10/2; => $e == ($b = ($c = ($d = 5)))
pour les
chaînes
de caractères:
.
pour concatener. ex: $a = "addi" . "tionner" => $a
== "additionner"
x
pour réitérer une chaine. ex: $a x 2;
=> "additionneradditionner"
Les
opérateurs
de comparaison pour les nombres: (retourne vrai ou faux)
==
égale
à.
ex: ($b == $c) =>
vrai
!=
différant
de
ex: ($b != ($f=34727)) => vrai
<
plus petit
que
ex: ($b < $f)
=> vrai
<=
plus petit ou égale ex: ($b
<=
$c) => vrai
>
plus
grand
ex: ($b > $c)
=>
faux
>=
plus grand ou égal
ex:
($b >= $c) => vrai
Les
opérateurs
d'affectation: ("=" est l'opérateur habituel d'affectation)
Les opérateurs
d'affectation fonctionnent comme en C. Donc :
$a += 2;
# est équivalent à: $a = $a + 2;
**=
élevé
à la puissance de ex: $b **= 2;
=>
25
+=
plus égale
ex: $b += 5; => 30
*=
multiplier
par égale ex: $b *=
2;
=> 60
&=
<<=
&&=
et
égale
-=
moins
égale
/=
|=
>>=
||=
ou
égale
.=
%=
^=
x=
occurence
L'opérateur
conditionnel
"?:" exactement comme en C.
?
?: motif
(On dit
"si-alors-sinon":
Si
vrai
avant le ? alors le
vrai
est avant le : sinon le
vrai
est aprés. exemple:
printf "
%darrive
%s.\n",
$n,
($n
== 1) ? '' :
"nt";
de comparaison pour
les
chaines: (retourne vrai ou faux)
eq
egale
ne
pas egal
le
inférieur ou égal
lt
inferieur
ge
superieur ou égal
gt
superieur
en vrac quelques autres:
**
élévation à la puissance
&&
et logique
||
ou logique
++
incrémentation
--
décrémentation
not
non logique
and
et logique
or
ou logique et xor ou exclusif
|
ou bit à
^
ou exclusif bit à
&
et bit à
?:
(si-alors-sinon) (if-then-else)
les fonctions:
--------------
label: description ultr rapide:
chomp
éfface
le
dernier caractére de saut de ligne ex: chomp
$saisie;
pop
ote le dernier
element
de la liste. ex:
pop(@liste);
shift
ote le premier
element
de la liste. ex: shift(@list);
sort
tri la liste
donnée.
ex: @files = sort readdir(REP);
push
ajoute un element à la fin de la liste. ex:
push
@liste, $element;
unshift
ajoute un
element
au debut de la liste. ex:
unshift(@list,"$a");
map
créé
une liste résultant des elements modifier par EXPR de LIST
exp: @nw_liste = map (($_ *4):100
grep
créé une sous-liste avec les éléments
matchés
d'une liste
lc
pour lowercase, met les
caractères
en majuscule.
split
éclate l'expression à chaque
motifs
et retourne les champs ainsi créés:
ex: ($nom, $prenom) = split(/\./, $line);
open
ouvre un fichier via un
Filehandle.
ex: open F, "$file" or die "shit $!";
opendir
comme open mais pour
les
repertoires. ex: opendir REP, "$dir" or die "redremer
$!";
readdir
lit et retourne le
contenu
d'un repertoire ex: @contenu = readdir(REP);
localtime
fonction
comprenant plusieurs champs (sec,min,h,j,mois,année,et d'autres
style jours en chaine, mois en chaine, etc... a voir) qui donne le
nombre
d'elements de champ écoulés depuis 1900 jusqu'a ici
maintenant.
exemple:
$dayname
= (dim,lun,mar,mer,jeu,ven,sam)[(localtime(EXPR))[6]];
#ou expr est la date en sec depuis 1970 (dans la plus part des systems)
Les
Variables Spéciales
Les variables
spéciales
qui seront toutes spécialement reconnu par perl (La plupart sont
en lecture seule).
Elles servent à
situer
quelque chose, a faire référence à quelque chose ,
pas à être modifié en leurs assignant une nouvelle
valeur.
On trouve souvent leurs
homologue dans les shells.
Variables spéciales des expressions rationnelles:
$chiffre $1 Texte trouvé par le jeu corespondant de parenthéses dans le dernier motif trouvé.
$& $MATCH La chaine trouvée par la dernière recherche réussie
$` $PREMATCH La chaine précédant (ce qui était avant la chaine qui a matché) la chaine trouvée par la derniére recherche réussie.
$' $POSTMATCH La chaine suivant (ce qui été aprés la chaine matché) ce qui à été trouvé par la derniére recherche réussi
exemple:
$_ = 'Perl is really bonnard';
/really/;
print "$`:$&:$'\n";
> Perl is :really: bonnard
$+ $LAST_PAREN_MATCH
$* $MULTILINE_MATCHING
Variables globales spéciales:
$_
$ARG
L'espace d'entrée et de recherche
de motifs par defaut (la ligne ou le fichier sur lequel vous allez
chercher)
à savoir que Perl prend souvent $_ même si on ne l'utilise
pas dans les cas suivant:
- Test sur les fichiers (-f , -d) sauf -t qui prend STDIN par defaut
- les fonction print et unlink .
- les operations de recherche de motifs m//, s///, tr/// quand
elles
sont utilisées sans l'opérateur =~
- La variable d'itération par defaut (si aucune autre variable
n'est
fournie).
- Variable d'iteration implicite des fonctions grep et map.
- L'endroit par defaut ou est placé un enregistrement
d'entrée
quand le résultât d'une opération <FH>
(FileHandle)
est testé par elle même comme seul critère d'un
test
while.
while (<>) {...}
pour
while (defined($_ = <>)) {...}
$.
$INPUT_LINE_NUMBER
$NR
le numéro de ligne du dernier handle de fichier lu
(exp: $ perl -e 'exit if
$. > 15' note.log
# afin d'afficher les 15 premières lignes du fichier note.log)
$/
$INPUT_RECORD_SEPARATOR
$RS
le séparateur d'enregistrement d'entré, le
caractère
saut de ligne par defaut
$,
$OUTPUT_FIELD_SEPARATOR
$OFS
le séparateur de champ en sorti pour print
$\
$OUTPUT_RECORD_SEPARATOR
$ORS
le séparateur d'enregistrement en sorti pour print
$"
$LIST_SEPARATOR
Identique au $, mais s'applique aux valeurs de liste interpolées
dans une chaine entre " ou espace
(dans pas longtemps la suite des Variables Spéciales ici , à noter que vous pouvez trouver la suite dans le livre Programmation en Perl (indispenssable))
(note: pour le compte du temps il y a pleins de controle (fonctions)
applicable gtime, localtime, time, stat[les_derniers_champs]
bon enfin il y en à plein que je me ferai un plaisir de citer,
mais j'ai pas le temps, demain peut-être (
voici
un petit exemple)
Quand au fonctions il y en à vraiement un gros faxon, toutes
importantes et je vais essayé de les nomées en donnant
d'autres
exemples que ceux des sites ou livres pour ce faire une idée,
mais
ça bouffe beaucoup de temps alors demain peut-être.)