INTRODUCTION AU LANGAGE PERL

INTRODUCTION AU
LANGAGE PERL
I Presentation du langage PERL
Ce document a pour but de vous fournir un outil simple et rapide à
consulter lors de développements réalisés en langage PERL.
Le support que j'ai utiliser pour produire ce document est le livre de
Randall L.Schwartz "introduction à Perl" aux éditions O'Reilly ainsi que
de quelques autres documents sur le sujet.
IMPORTANT :
Pour chaque élément du langage, j'ai crée un petit programme
d'exemple afin de montrer et le coté théorique et le coté
pratique ce qui manque souvent. Il y'a plus de 60 petits
programmes commentés et testés.
Ces programmes ne demande aucun droit particulier pour les executer
et ne risque en aucun cas de détruire votre système :).
P.E.R.L signifie Pratical Extraction and Report Language ce qui veut dire en
français Extraction Pratique et Langage de Rapport.
Ce langage n'est pas un langage compilé a proprement dit comme le langage C
par exemple, mais ce n'est pas non plus un langage interpreté comme le shell
mais plutot un melange des deux.
En effet il analyse d'abord le programe en entier avant de l'executer mais
ne produit aucun fichier objet comme le fait un interpreteur.
Pour utiliser ce langage il suffit de disposer les instructions dans un
fichier, rendre ce fichier executable et à l'appel de ce fichier, l'execution
se fera comme avec un programe écrit en langage shell.
Avant toutes choses deux éléments sont necessaires :
-> le logiciel PERL
-> indiquer dans votre fichier que votre programe est un programe PERL
Si le deuxième point n'est pas satisfait, le programme sera executé comme
s'il était écrit en langage shell.
La directive indiquant que ce programme est un programme en langage PERL est
la suivante : #!/perl
On indique le répertoire dans lequel se trouve le binaire perl.
Par exemple si le binaire se trouve dans /usr/local/bin la directive sera
#!/usr/local/bin/perl
Attention ne confondez pas la directive et les commentaires qui eux aussi
commencent par le signe #.
II Le langage
J'ai choisi de le résumer de la manière suivante. Chaque partie importante
aura un chapitre qui lui sera dédié (affichage des données, stockage,
structures ...).
II.1 Stockage des données
Vous pouvez utiliser le même nom pour des types de variables différents
($nom, @nom, %nom). En effet ces éléments ont des espaces de stockage
indépendants donc sont des éléments différents.
D'un point de vue pratique, cela n'est pas recommandé car vous risquez
de ne plus vous y retrouver.
a) Les variables :
notation : $variable
exemple : $valeur = "bonjour";
b) Les tableaux ou les listes :
notation : @liste ou $liste[indice] <=> @liste[indice]
- Le premier indice est l'indice 0.
- Les indices de tableau peuvent etre soit de type numérique soit de type caractère.
$liste[23]="a"; ou $liste["aaa"]="b";
- Une liste peut etre un ensemble de données (1,2,3) ou un ensemble
d'expressions ($a+$b,$c+$a) ou un mélange des deux.
- La liste vide est notée : ()
- Afin de connaitre l'indice du dernier éléments stockés dans une liste : $#liste
- Afin de connaitre le nombre d'éléments stockés dans une liste :
$nb = @liste; ou $#liste + 1
Quelques exemples de manipulation d'une liste :
@liste = ("a","b","c");
@liste[0] ou $liste[0] -> a
$#liste -> 2
$nb = @liste; -> 3 (affectation scalaire)
($nb) = @liste -> le premier élément a (affectation de tableau)
@liste=(@liste,"d"); -> a, b, c, d
@liste[0..2] -> a, b, c
@liste[0,1] = @liste[1,0]; -> b, a, c, d (inversion de 2 éléments)
<=> ($liste[0],$liste[1]) = ($liste[1],$liste[0]);
c) Les tableaux associatif :
notation : %tableau
Le tableau associatif permet d'associer 2 éléments et ainsi de faire une
paire avec une clé et une valeur. (clé,valeur)
Quelques exemples de manipulation d'un tableau associatif :
%tableau = ("a","1","b","2");
$cle="a"; $tableau{$cle} -> 1
Affichage du tableau trié par ordre croissant :
for $key (sort keys %tableau)
{ print "la clé $key correspond à la valeur $tableau{$key}\n";}
Il y'a un tableau particulier qui peut etre interessant et qui contient
les valeurs de votre environnement : %ENV
$cle = "PATH";
%ENV{$cle}; -> retournera les chemins contenus dans la variable PATH
d) Les valeurs numériques sont stockées en décimales flottantes en double précision.
II.2 Les bases de données et les tableaux dbm
Ce système est une bibliothèque qui fournit un utilitaire simple de gestion de base de données
en stockant des paires (clé,valeur) sur disque.
Une fois ouverte, toutes les manipulations seront repercutées dans les fichiers sur disque.
Important : à la fin de chaque clé un caractère NULL est ajouté au moment du stockage. Il faut
donc pour récupérer une valeur procéder de la manière suivante :
$val = $tab{"cle\0"};
chop($val); #pour l'affichage
a) Pour associer une base de données dbm à un tableau dbm :
dbmopen(%tableau_associatif,"dbmfichier",$mode);
Le premier paramêtre est un tableau associatif
Le deuxième paramêtre est la base de données composée de deux fichiers dbmfichier.dir et
dbmfichier.pag.
Le troisième paramêtre est le mode d'accès en octal du fichier. Si le fichier existe déjà ce
paramêtre n'est pas utile et peut etre remplacé par la valeur indéfinie undef.
b) Pour stopper l'assocation entre le tableau et la base de données :
dbmclose(%tableau_associatif);
c) Pour accéder à des données ayant une taille fixe :
Cette méthode permet d'atteindre les données (enregistrements) de manière plus rapide et
plus direct en "sautant" autant d'octets que nécessaire.
- L'ouverture :
open(DESC,"mode");
Où mode est : +fic on crée le fichier fic puis on l'ouvre en Lec./Ecr.
+>>fic on ouvre ou on crée (si fic n'existe pas) puis on ouvre en Lect./Ecr.
- Le positionnement :
seek(DESC,nb_octets_a_passer,position_de_départ);
- L'écriture :
print DESC données;
Attention il est impératif que les données soient de la taille d'un enregistrement. Une fonction
est pratique pour faire cela pack.
print DESC pack("format",$champ1,$champ2, ...);
Où format désigne le nombre d'octets de chaque champ.
Exemple : A40AA20s
A40 indique que le premier champ sera formaté sur 40 octets
A indique que le deuxième champ sera formaté sur 1 octet
A20 indique que le troisieme champ sera formaté sur 20 octets
s indique que le quatrième champ sera formaté sur un entier court (2 octets)
- L'écriture :
read(DESC,$buffer,$nb_octets_a_lire);
La valeur de retour est le nombre d'octets lus.
Une fois l'enregistrement lu il faut récupérer chaque champ. Une fonction du même ordre que
pack nous y aide : unpack.
L'enregistrement est stocké dans la variable buffer.
($champ1,$champ2,...) = unpack("format",$buffer);
(La partie format a été expliqué au dessus)
II.3 Lecture des données
stdin est l'entrée standard par défaut. Chaque élément lu conserve en dernier caractère le
retour chariot (\n) d'où l'utilisation d'une commande supprimant le dernier caractère d'une
variable : chop.
a) Au clavier :
$name = <stdin>; # le retour chariot termine la lecture
@liste = <stdin>; # chaque ligne entrée est un élément du tableau. Il
# est nécessaire de finir par <ctrl><d>
En boucle (pour terminer la boucle <ctrl><d>) :
while(<>)
# <> est l'opérateur diamond
{ print "la valeur : $_\n"; } # $_ est la variable de stockage
# par défaut si aucune n'est précisée
<=>
while($valeur = <stdin>)
{ print "la valeur : $valeur\n"; }
b) Dans un fichier :
Tout comme dans la majorité des langages, il est nécessaire d'ouvrir le fichier, de récupérer les
données et de le refermer.
open(DESC,"fichier");
# On ouvre le fichier
while($valeur = <DESC>)
# On lit les données par lignes
{
chop($valeur);
# On supprime le retour chariot
print "la valeur : $valeur\n"; # On affiche la valeur lue
}
close(DESC);
# On ferme le fichier
On pourrait comme précédemment pu utiliser la variable par défaut :
open(DESC,"fichier");
# On ouvre le fichier
while(<DESC>)
# On lit les données par lignes
{
chop;
# On supprime le retour chariot
print "la valeur : $_\n"; # On affiche la valeur lue
}
close(DESC);
# On ferme le fichier
c) En ligne de commande lors du passage de paramêtres :
Les arguments sont stockés dans un tableau prédéfini : @ARGV
$ARGV[0] -> premier paramêtre
Si il n'y a pas de paramêtre @ARGV renvoie '-' ou $#ARGV -1
if(@ARGV == '-') {print "Aucun parametre sur la ligne de commande\n";}
<=>
if($#ARGV == -1) {print "Aucun parametre sur la ligne de commande\n";}
II.4 Ecriture des données
stdout est la sortie standard par défaut.
Le backslash (\) permet de désactiver la spécificité de certains caractères.
a) Sortie simple
- A l'écran :
simple : print "Je suis sur votre écran\n";
print "la valeur est : $tab{\"cle\"}\n";
formaté : printf "%6s %3d %4.2f\n",$s,$d,$f;
%6s sortie caractère sur 6 caractères
%3d sortie d'un entier sur 3 caractères
%4.2f sortie d'un réel sur 4 caractères dont 2 apres la virgule
- Dans un fichier :
DESC est le descripteur du fichier de sortie à ouvrir avant l'écriture
grace à la commande open. n'oubliez pas de le fermer au moyen de la
commande close.
simple : print DESC "Je suis dans votre fichier\n";
formaté : printf DESC "%6s %3d %4.2f\n",$s,$d,$f;
b) Sortie formatée en utilisant le mot clé format :
Ce type de sorties permet d'avoir un affichage plus précis avec un format prédéfini (un peu
comme avec un printf mais plus simple d'utilisation et plus puissant).
Pour définir un format vous devez utiliser le mot clé format et le définir puis afficher vos
résultats au moyen de la commande write.
- Description d'un format :
format nom_du_format =
descriptif de la sortie
.
nom_du_format :
2 types de nom sont possibles, pour l'entête et pour le corps de
l'affichage. (NOM_TOP et NOM)
Attention :
N'oubliez pas le caractère . (point) qui termine la définition d'un
format. Ce point doit être en première colonne dans votre fichier sinon
vous risquez d'avoir une erreur.
descriptif de la sortie :
Ce descriptif comprend 2 parties essentielles
1. le format d'affichage
2. les variables à afficher
1. le format d'affichage
Cette partie permet de connaitre la façon dont vont etre
affichées les données (l'endroit, la manière, la taille ...)
La taille est définie par le nombre de signes présents apres le signe @
ou ^
@>>>> indiquera que la valeur sera affichée sur 4 caractères justifiés
à droite
@<<<< même chose mais justifié à gauche
@|||| même chose mais centré
@###.## champ numérique avec 2 chiffres apres la virgule
@* champ multiligne, on ne s'occupe pas de la taille du champ à afficher
^>>> affichera un champ sur plusieurs lignes de 3 caractères lignes
vides incluses
~ ^>>> même chose mais sans les lignes vides
~~ ^>>> même chose mais répétera l'affichage jusqu'à trouver une
ligne vide
2. les variables à afficher
$variables1,$variables2, ....
- Affichage à l'écran :
Le nom du format sera STDOUT qui par défaut est la sortie standard.
STDOUT_TOP sera le nom du format pour l'entête.
- Affichage dans un fichier :
Le nom du format sera le nom du descripteur du fichier (par exemple DESC).
DESC_TOP sera le nom du format pour l'entête.
- Quelques exemples :
* On désire écrire les noms et prènoms des personnes contenus dans
un tableau associatif par colonnes avec comme entête les mots
Nom Prènom et ceci à l'écran.
format STDOUT_TOP =
# Permet d'écrire la première ligne
Nom Prénom
# La première ligne
.
# Fin du format pour l'entête
format STDOUT =
# Permet d'écrire les données formatées
@>>>>>>>> @>>>>>>>>>> # Format d'affichage des 2 champs justifié à droite
$nom, %tab{$nom}
# le nom sur 8 caractères et le prènom sur 10
.
# Fin du format
foreach $nom (keys %tab)
{
$prenom = @tab{$nom};
write;
}
# boucle permettant l'affichage du tableau
Attention : Ne pas mettre de commentaires comme ici dans la définition
d'un format ceux-ci seraient affichés lors de l'affichage.
* On désire faire la même chose mais dans un fichier.
Nous allons donc nommer le format du nom du descripteur du fichier.
format DESC_TOP = ... # Sera l'entête lors de l'affichage dans le fichier
# référencé par le descripteur DESC
format DESC = ...
# Sera le format d'affichage du corps
# dans le fichier
open(DESC,">fichier"); # On ouvre en écriture le fichier "fichier"
# référencé par le descripteur DESC
foreach $nom (keys %tab)
# boucle permettant l'affichage du tableau
{
$prenom = @tab{$nom};
write DESC;
# On affiche les résultats dans le fichier
}
close(DESC);
# On ferme le fichier
Des fichiers contenant des programmes sont fournis pour vous aider à mieux comprendre les
formats. (format.ex formatfic.ex formatmul.ex)
II.5 Autres mots clès
# chop
Ce mot clè permet de supprimer le dernier caractère contenu dans une
variable. Il est notamment très utile pour supprimer le retour chariot
lors de la lecture au clavier des données :
Syntaxe :
chop($variable);
# if
Syntaxe :
if(expression)
{
VRAI;
}
else
{
FAUX;
}
{
ou if(expression)
VRAI;
}
elsif(expression2)
{
VRAI2;
}
....
else
{
FAUX;
}
La syntaxe abrégée peut etre utile mais est aussi moins facilement comprehensible :
(expression)?VRAI;:FAUX; # Est équivalent au premier cas
# unless
Syntaxe :
unless(expression) ou (expression)||FAUX;:VRAI;
{
FAUX;
}
else
{
VRAI;
}
# rename
Permet de renommer un fichier sous un autre nom.
Syntaxe :
rename($fichier,"$autre_nom");
# time
Renvoie l'heure système qui est le nombre de secondes écoulées
depuis le 1er Janvier 1970 à minuit GMT.
Pour obtenir un écart en heure entre deux heures :
($time1 - $time2)/3600
Syntaxe :
time();
# keys
Permet de récupérer dans un tableau associatif la clé ou les clés
dans un ordre quelconque afin de trouver ensuite la donnée qui lui
est associée. Keys renvoie vide si le tableau est vide.
Syntaxe :
keys(%tableau)
dans une boucle :
foreach $cle (keys %tableau)
{
$donnee = %tableau{$cle};
print "la donnee $donnee est associee a la cle $cle\n";
}
# foreach
Ce mot clé permet de réaliser une boucle en recupérant tous les
élément d'une liste.
Syntaxe :
foreach $cle (@liste)
{
instruction;
}
Exemple :
@liste = (1,2,3,4);
foreach $element (@liste)
{
print "l'element est : $element\n";
}
# sort
Trie les éléments par ordre alphabétique.
Syntaxe :
@liste_trie=sort(@liste)
# for
Boucle permettant d'effectuer une action autant de fois que l'on désire.
Syntaxe :
for(valeur_initiale;test;incrementation)
{
commande;
}
Exemple :
for($i=1;$i<=10;$i++)
{
print "Le numero est $i\n";
}
# while
Boucle permettant d'effectuer une action tant qu'une condition est
vraie.
Syntaxe :
while(condition)
{
instruction;
}
# until
Boucle permettant d'effectuer une action tant qu'une condition est
fausse.
Syntaxe :
until(condition)
{
instruction;
}
# tr
Comme en shell cette commande permet de transformer une chaine en
une autre chaine ou de modifier des occurences dans une chaine.
Syntaxe :
Voir le man tr
Exemple :
$name =~ tr/A-Z/a-z/; # Transforme toutes les majuscules en minuscules
$name =~ tr/er/ab/; # Transforme les e en a et les r en b
# sprintf
Permet de formater une sortie.
Syntaxe :
sprintf(format,variables);
Exemple :
$res = sprintf("Pour la sortie du film %s\n",$nom);
# sleep
Suspend le déroulement du programme durant le laps de temps indiqué.
Syntaxe :
sleep secondes;
# length
Renvoie le nombre de caractères de la chaine.
Syntaxe :
length(chaine);
# split
Découpe et range dans une liste les éléments trouvés contenus entre un
délimiteur défini.
Syntaxe :
split(delimiteur,$variable);
Exemple :
$a = "1:2:3:4::5";
@liste = split(/:/,$a); -> ("1,"2","3","4","","5")
# join
Cancatene une valeur à chaque element d'une liste et range le tout dans une
variable.
Syntaxe :
join($valeur,@liste);
Exemple :
$valeur = "+";
@liste = ("1","2","3","4");
$res = join($valeur,@liste); -> ("1+2+3+4+")
# die
Permet de terminer un programme au moment ou on passe sur le die et
de faire une sortie écran au même moment.
Syntaxe :
die "c'est la fin\n";
# last
Permet de sortir d'une boucle avant la fin normale de celle-ci comme
break en C par exemple.
Un label peut lui etre associe afin de continuer l'execution du programme
à un endroit particulier.
Syntaxe :
last ou last LABEL;
# next
Permet de passer au traitement de l'élément suivant dans une boucle et
d'abandonner le traitement de l'élément en cours.
Un label peut lui etre associe afin de continuer l'execution du programme
à un endroit particulier.
Syntaxe :
next ou next LABEL;
# redo
Permet de recommencer le traitement de l'élément en cours sans effectuer
le traitement apres le redo.
Un label peut lui etre associe afin de continuer l'execution du programme
à un endroit particulier.
Syntaxe :
redo ou redo LABEL;
# undef
Définie la chaine vide. Avant toutes opérations, une chaine à cette valeur.
# push
Ajoute un élément ou plusieurs en fin de liste (à droite).
Syntaxe :
push(@liste,$elemt1,$elemt2,...) <=> @liste=(@liste,$elemt1,$elemt2,...)
voir pop
# pop
Retire le dernier élément de la liste (à droite).
La valeur de retour est l'élément supprimé.
Syntaxe :
pop(@liste)
voir push
# unshift
Ajoute un élément ou plusieurs en début de liste (a gauche).
Syntaxe :
unshift(@liste,$elemt1,$elemt2,...) <=> @liste=($elemt1,$elemt2,.,@liste)
Voir shift
# shift
Retire le premier élément de la liste (a gauche).
La valeur de retour est l'élément supprimé.
Syntaxe :
shift(@liste)
voir unshift
# reverse
Inverse le sens de la liste.
Syntaxe :
@liste_inversee=reverse(@liste)
# values
Renvoie les valeurs contenues dans un tableau associatif.
Syntaxe :
values(%tab);
# each
Renvoie chaque éléments du tableau associatif.
Syntaxe :
($cle,$val)=each(%tab);
# delete
Détruit un couple de valeur dans un tableau associatif.
Syntaxe :
delete($tab{$cle});
# stat
Renvoie 13 champs d'informations concernant un fichier.
Syntaxe :
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,
$blksize,$blocks) = stat($fichier);
# lstat
Renvoie 13 champs d'informations concernant le lien symbolique et non
sur le fichier pointé.
($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,$atime,$mtime,$ctime,
$blksize,$blocks) = lstat($fichier);
# chdir
Permet un changement de répertoire.
Renvoie vrai si le changement s'est bien passé.
Syntaxe :
chdir($chemin);
# opendir
Ouvre un descripteur de répertoire.
Syntaxe :
opendir(descripteur,$repertoire);
voir closedir, readdir
# closedir
Ferme un descripteur de répertoire.
Syntaxe :
closedir(descripteur);
voir opendir, readdir
# readdir
Liste le contenu du répertoire pointé par le descripteur ouvert par
opendir.
Syntaxe :
readdir(descripteur);
voir opendir, closedir
# unlink
Detruit un ou plusieurs fichiers.
Syntaxe :
unlink($fic1,fic2,...);
Il est possible de detruire plusieurs fichiers en utilisant une
expression :
unlink(<*.o>); detruira tous les fichiers ayant une extension .o
Le < et le > permettent d'inhiber le caractere special *
# system
Realise des appels système.
Syntaxe :
system("appel");
# link
Crée un lien en dur entre deux fichiers (equivalent a ln)
Syntaxe :
link($fichierorigine,$fichierlien);
# symlink
Crée un lien symbolique entre deux fichiers (equivalent a ln -s)
Syntaxe :
symlink($fichierorigine,$fichierlien);
# readlink
Donne les renseignements sur le fichier lié par la commande
symlink (équivalent à ls -l)
Syntaxe :
readlink($fichier);
# mkdir
Crée un repertoire.
Syntaxe :
mkdir($repertoire,$droit);
# rmdir
Detruit un répertoire
Syntaxe :
rmdir($repertoire);
# chmod
Permet de modifier les droits sur un ou plusieurs fichiers ou un
ou plusieurs répertoires.
La valeur de retour de la commande est le nombre de modifications
effectuées.
Syntaxe :
chmod($droits,$fichier1,$fichier2, ...);
$droit est en octal 0777 donnera tous les droits a tout le monde
On peut modifier plusieurs fichiers en utilisant une expression :
chmod(0777,<*.o>); changera les droits a tous les fichiers ayant
l'extension .o
# chown
Permet de modifier le proprietaire d'un fichier ou d'un répertoire.
Pour l'utiliser il vous faut avoir des droits particuliers la plupart
du temps.
La valeur de retour de la commande est le nombre de modifications
effectuées.
Syntaxe :
chown($uid,$gid,$fichier1,$fichier2,..);
$uid est le numéro d'identification de l'utilisateur
$gid est le numéro d'identification du groupe
# utime
Permet de changer la date des fichiers ou répertoires au niveau de
la date de dernière modification et de la date de dernier changement
de l'inode.
La valeur de retour de la commande est le nombre de modifications
effectuées.
Syntaxe :
utime($date_modification,$date_inode,$fichier1,$fichier2,..);
# index
Renvoie l'emplacement d'une sous-chaine de caractères dans la chaine
indiquée ou -1 si cette sous-chaine n'existe pas.
Attention les indices commencent à l'indice 0.
La chaine est parcourue par la gauche.
Le paramêtre $position permet de faire un recherche à partir d'un
indice precis.
Syntaxe :
index($chaine,$sous-chaine);
ou
index($chaine,$sous-chaine,$position);
# rindex
Renvoie l'emplacement d'une sous-chaine de caractères dans la chaine
indiquée ou -1 si cette sous-chaine n'existe pas.
Attention les indices commencent à l'indice 0.
La chaine est parcourue par la droite.
Le paramêtre $position permet de faire un recherche à partir d'un
indice precis.
Syntaxe :
rindex($chaine,$sous-chaine);
ou
rindex($chaine,$sous-chaine,$position);
# substr
Permet d'extraire et de substituer une sous-chaine d'une chaine.
Si la valeur de $depart est négative, la substitution se fera par
la droite (fin de la chaine).
Si la chaine résultat est à gauche, le résultat du substr sera
stockée dans cette chaine. Si la chaine résultat est à droite,
cette chaine devient la chaine de substitution et remplacera les
éléments selectionnés. La longueur de cette chaine peut etre
inferieure ou superieure à la longueur de substitution, la chaine
résultat sera d'autant plus courte ou plus longue.
Syntaxe :
$subst = substr($chaine,$depart,$longueur);
ou
substr($chaine,$depart,$longueur)= $rempl;
II.6 Les sous-programmes
Les sous-programmes permettent de developper de manière modulaire
dans le cas ou plusieurs personnes se partagent le travail par
exemple. Mais aussi permettent de structurer et de clarifier le
programme.
Syntaxe :
définition :
sub sous_programme
{
local($param1);
instructions ...
}
appel :
&sous_programme($el1,$el2);
Le partie "local" permet d'utiliser des variables locales qui en
dehors du sous-programme ne seront pas vues.
Les variables passees en argument (el1 et el2) sont stockées
dans une liste qui est : @_ .
La valeur de retour d'un sous-programme est la dernière évaluation.
II.7 Manipulation de fichier
Pour etre utiliser un fichier que se soit en lecture et\ou en ecriture
doit etre associé à un descripteur de fichier.
Les deux éléments importants sont open et close.
Syntaxe :
open(DESC,"fichier");
...
close(DESC);
Les différents mode d'ouverture :
en lecture : open(DESC,"fichier");
en ecriture : open(DESC,">fichier");
en ajout : open(DESC,">>fichier");
Ces manipulations de fichier peuvent etre utiliseés pour ouvrir et
fermer une commande systeme qui sera alors associée à un descripteur
de fichier.
Exemple :
open(MAIL,"|mail [email protected]");
print MAIL "Bonjour et a bientot\n";
close(MAIL);
II.8 Les opérateurs
a) Les nombres
addition
:+
soustraction : multiplication : *
division
:/
exponentiel : **
modulo
:%
b) Les nombres et les caractères
Signification
Nombre
Caractére
Egal
« == »
eq
Différent
« != »
ne
Inférieur
«<»
lt
Supérieur
«>»
gt
Inférieur ou égal
«>»
le
Supérieur ou égal
« >= »
ge
c) Les caracteres
cancatenation :
repetition : x
evaluation : =~
\Ufred
: FRED
\ufred
: Fred
\LFRED
: fred
\lFRED
: fRED
d) Les fichiers
L'utilisation peut etre faite de cette manière :
if( operateur $fichier_repertoire) ....
Operateur | Signification
--------------------------------------------------------r
| Le Fichier ou le Répertoire sont lisibles
-w
| F ou R modifiables
-x
| F ou R executables
-o
| F ou R proprietaire de l'utilisateur
-R
>
-W
>
> Meme test que precedemment mais en fonction
-X
> de la presence ou non d'un setuid
-O
>
-e
| F ou R existent
-z
| F existe et sa taille est nulle
-s
| F ou R existent et sa taille est non nulle
-f
| C'est un Fichier
-d
| C'est un Repertoire
-l
| C'est lien symbolique
-b
| Fichier special de type bloc (Disque ..)
-c
| Fichier special de type caractere (E/S ..)
-u
| F ou R disposant d'un setuid
-g
| F ou R disposant d'un setgid
-T
| Fichier de type texte
-B
| Fichier de type binaire
-M
| Age de la dernière modification en jours
-A
| Age du dernier acces en jours
-C
| Age de la dernière modification de l'inode en jours
-------------------------------------------------------II.9 Traitement sur les utilisateurs et les groupes
Il est parfois utile notamment pour ce qui est de l'administration
de serveur de pouvoir recuperer les informations sur les utilisateurs.
Pour cela plusieurs commandes sont disponibles.
a) Récupération des informations sur un utilisateur
# getpwnam
Renvoie les informations sur un utilisateur a partir de son nom.
Les informations retournees sont les suivantes celles contenues
dans le fichier /etc/passwd :
($name,$passwd,$uid,$gid,$quota,$comment,$gcos,$dir,$shell)
Syntaxe :
@info = getpwnam($nomuser);
# getpwuid
Renvoie les informations sur un utilisateur a partir de son numero
d'indentification.
Les informations retournees sont les suivantes (celles contenues
dans le fichier /etc/passwd) :
($name,$passwd,$uid,$gid,$quota,$comment,$gcos,$dir,$shell)
Syntaxe :
@info = getpwuid($uid);
# setpwent
Initialise le parcours du fichier /etc/passwd.
Syntaxe :
setpwent
Voir aussi getpwent et endpwent
# getpwent
Permet de lire l'entrée suivante dans le fichier /etc/passwd.
Syntaxe :
getpwent
Voir aussi setpwent et endpwent
# endpwent
Ferme le parcours du fichier /etc/passwd.
Syntaxe :
endpwent
Voir aussi setpwent et getpwent
b) Récupération des informations sur un groupe
# getgrnam
Renvoie les informations sur un groupe a partir de son nom.
Les informations retournees sont les suivantes (celles contenues
dans le fichier /etc/group) :
($name,$passwd,$gid,$members)
Syntaxe :
@info = getgrnam($nomgroupe);
# getgrgid
Renvoie les informations sur un groupe a partir de son nom.
Les informations retournees sont les suivantes (celles contenues
dans le fichier /etc/group) :
($name,$passwd,$gid,$members)
Syntaxe :
@info = getgrgid($uid);
# setgrent
Initialise le parcours du fichier /etc/group.
Syntaxe :
setgrent
Voir aussi getgrent et endgrent
# getgrent
Permet de lire l'entrée suivante dans le fichier /etc/group.
Syntaxe :
getgrent
Voir aussi setgrent et endgrent
# endgrent
Ferme le parcours du fichier /etc/group.
Syntaxe :
endgrent
Voir aussi setgrent et getgrent
II.10 Les paramêtres par défaut de l'environnement
Il est possible que les paramêtres définis par défaut ne vous conviennent
pas. Vous voulez que l'entrée standard, le nombre de lignes par pages ...
ne soient pas celles par défaut. Vous pouvez alors creer votre propre
environnement grace à la commande select.
La valeur de retour de select est l'ancien environemment. Vous pouvez le
récuperer ainsi il vous suffira de refaire un select et vous reviendrez dans
l'environement precedent.
Vous devez utiliser la commande write pour l'affichage sinon n'oubliez
pas de décrementer le nombre de lignes restant pour l'affichage.
Attention si vous ne voulez pas utiliser la sortie ecran vous devrez
faire comme avec un format en utilisant un descripteur.
Syntaxe :
select($param);
Paramêtres |
Signification
------------------------------------------------------------------$~
| Format de sortie ou label (voir format)
$^
| Format d'entête
$=
| Nombre de lignes par pages
$| Nombre de lignes restant pour l'affichage dans la page