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