Instructions diverses
chomp
Vérifie si les derniers caractères d'une chaîne ou d'une liste de chaînes concordent avec le(s) caractère(s) de séparation des lignes d'entrée (définis dans la variable système $/), et les supprime si c'est le cas. Syntaxe :
nb = chomp ($chaine);
# affecte le
nb de caractères supprimés à nb
$/ peut être modifié à volonté :
$/ = "...";
# considère
... comme marque de fin de ligne
defined
Permet de tester si une variable ou un élément de tableau est défini. Peut être utilisé comme condition de test, par exemple :
if (defined($var)) {
print "Cette variable est
déjà définie, il vaudrait mieux ne pas
l'écraser\n";
}
undef
Permet d'annuler la définition d'une variable ou
d'un élément de liste
require
Permet de faire appel à un fichier Perl externe.
require ("fichier.pl");
Comme pour un sous-programme, la valeur de retour de l'appel
à require est la valeur de la dernière expression
évaluée dans le fichier. Si elle est nulle,
l'éxécution s'interrompt.
Appeler des commandes système
Cela peut se faire en mettant la commande entre accents graves :
$monlogin = `whoami` ;
chop $monlogin ;
print "Bonjour, $monlogin \n" ;
Le code de retour de la commande se trouve dans la variable
$?.
Variables système
$_ : la variable scalaire $_ est la variable par défaut : elle est utilisée par de nombreuses fonctions (recherche de modèle, substitution, transcription, ...) si aucune variable n'est spécifiée explicitement.
$#tableau : pour chaque tableau tab
défini, une variable du nom de $#tab
est définie et contient l'indice du dernier
élément. Noter que le nombre
d'éléments d'un tableau est donc donné
par $#tab + 1
, puisque la
numérotation des éléments commence (en
général, cf. $[
ci-dessous) à 0.
$0 : nom du programme
$/ : séparateur de lignes d'entrée
$\ : séparateur de lignes de sortie
$, : séparateur de champs de sortie
$" : séparateur d'éléments d'un tableau. Quand on demande d'afficher un tableau à l'intérieur d'une chaîne (print ("@liste");), la variable $" permet de spécifier le séparateur utilisé (l'espace, par défaut).
$# : format de sortie pour les nombres. Par défaut, les nombres sont imprimés avec vingt chiffres à virgule flottante en format compact. On peut le modifier, avec, par exemple : $# = "%.15g";
$@ : contient le message d'erreur retourné par un
appel à eval
.
$! : contient le message d'erreur produit par un appel à une fonction de bibliothèque système.
$. : numéro de ligne courant
$* : pour pouvoir faire des recherches de modèles
sur plusieurs lignes, il faut mettre $* à 1 (cf. option m
de la recherche de modèles)
$[ : permet de spécifier le premier indice d'un tableau. Par défaut, en Perl comme en C, les tableaux commencent à 0. On peut par ex. les faire commencer à 1 avec : $[ = 1;
$; : remplace automatiquement chaque virgule séparant deux indices dans un tableau associatif multi-dimensionnel
$: : spécificateur de coupures de mot
$^X : contient le premier mot de la ligne de commande tapée pour démarrer le programme
$& : mémorise la chaîne concordante lorsqu'un modèle est trouvé
$`et $' : mémorise le texte situé avant et après la chaîne concordante avec le modèle
$+ : mémorise le dernier modèle mis entre parenthèses
$% : numéro de page courant
$ARGV : nom du fichier courant (à ne pas confondre avec @ARGV qui contient la liste des éléments passés en paramètre)
@INC : contient la liste des répertoires dans
lesquels il faut rechercher les fichiers demandés par la
fonction require
(contient par
défaut le répertoire courant et le
répertoire Perl)
%INC : contient la liste des fichiers demandés par require
et trouvés.
%ENV : liste des variables d'environnement
Programmation orientée objet en Perl
En Perl, une classe est ce qu'on appelle un package, et une
méthode est simplement un sous-programme. On peut adresser
les variables d'une classe soit à l'aide de
l'opérateur ::
, soit à
l'aide de l'apostrophe. $classe::membre
est
donc identique à $classe'membre
.
On crée une classe de la manière suivante :
package ClasseExemple ;
# ...
instructions
# ...
1;
C'est le 1;
final qui indique la fin
de création du package. La première
méthode à ajouter est la méthode new
,
qui est le constructeur d'un objet. En voici la syntaxe type :
sub new {
my $this = {};
bless $this;
return $this;
}
{} construit une référence à un tableau associatif vide, et la valeur retournée à ce tableau est affectée à la variable locale $this.
La fonction bless permet de connecter l'objet référencé par $this à la classe.
Pour créer un objet, on écrira $objet
= new ClasseExemple;
ou encore $objet =
ClasseExemple->new( );
ou encore $objet
= ClasseExemple::new( );
Les arguments passés à une fonction new( ) pour un constructeur sont appelées variables de modèles. Elles sont utilisées pour initialiser chaque modèle d'objet lorsqu'il est créé.
Un constructeur pourrait ressembler à ceci :
sub new {
mon $type = shift ;
mon %parm = @_ ;
mon $ceci = { } ;
$ceci -> {'Nom'} =
$parm {'Nom'};
$ceci -> {'x'} =
$parm {'x'};
$ceci -> {'y'} =
$parm {'y'};
bless $ceci, $type;
}
On peut alors créer un objet de la manière suivante :
$obj = ClasseExemple::new('Nom' => 'top',
'x' => 10, 'y' => 20);
On accèdera alors aux variables ainsi :
print "$obj->{'x'}\n";
Packages et modules
Les noms de toutes les variables et de tous les sous-programmes définis à l'intérieur d'un programme sont stockés dans ce qu'on appelle un package. On peut en définir plus d'un par programme, et en changer en cours de programme à volonté. Exemple :
#! /bin/perl/
$var1 = 1 ; # var1 est enregistrée dans le
package main
package pack_un; # Création d'un nouveau package
$var2 = 2; # var2 est enregistrée dans le
package pack_un
$var1 = 3; # ... toujours dans pack_un ...
package main ; # on commute à nouveau vers main
print ("$var1\n"); # utilise la variable var1 de main, pas
celle de pack_un
print ("$pack_un::$var1\n"); # appelle pack_un sans commuter
On peut créer un package dans un fichier
à part, et l'enregistrer avec l'extension .pm, pour
créer ce qu'on appelle un module. Un module s'utilise
simplement avec l'instruction use monModule
dans
le programme principal.
Voici le code type d'un module :
#! /bin/perl
package monModule ; # définition du package
require Exporter ; # utilise le module
prédéfini Exporter ...
@ISA = qw (Exporter) ; # ... pour définir le
mode de communication
@EXPORT = qw (fonc1 fonc2) ; # définit les
sous-prog accessibles de l'ext.
@EXPORT_OK = qw ($var1 $var2); # définit les
variables accessibles de l'ext.
sub fonc1 {
$var1 +=10 ;
}
sub fonc2 {
$var2 += 20
}
Le débugger de Perl
Pour débugger un programme test
,
il suffit d'exécuter perl -d test
.
On en sort ensuite avec q
. Les commandes les
plus utiles sont les suivantes :
l fait défiler le listing du programme
l n
affiche la ligne n
/modèle/ affiche la ligne suivante contenant le modèle
?modèle? affiche la ligne précédente contenant le modèle
S liste tous les sous-programmes
s exécute une instruction. Entre dans les sous-prog, mais sans exécution
n exécute une instruction. N'entre pas dans les sous-prog, mais les exécute intégralement
r termine l'exécution d'un sous-programme et retourne à l'instruction qui suit son appel
X nomvar
affiche la variable $nomvar
b n
place un point d'arrêt
à la ligne n
c exécute le programme jusqu'au point d'arrêt défini
d n
supprime le point
d'arrêt de la ligne n
D supprime tous les points d'arrêt
commande
exécute la ligne
de commande tapée (quelle qu'elle soit)
a n com
exécute la
commande com
à la ligne n
H fait défiler les commandes précédentes
! n
exécute la commande n
(où n
apparaît dans le
listing fourni par H)
= racc
com
affecte la commande com
au raccourci racc
,
utilisable par la suite