Perl en concentré

Script

Shebantg perl : #!/usr/bin/perl
Perl doit être appelé avec l'option -w pour avoir plus d'informations en cas de développement/test (#!/usr/bin/perl -w)
La version minimale vitale est le perl 5.6

Types de données

  • $var est une variable scalaire –> [doubles () : le contenu est interprété] ; [simple (') : le contenu n'est pas interprété]
  • @tab est une variable de type tableau. On accède à l'élément x avec la notation $t[x]
  • %hash est une variable de type table de hachage.On accède à l'élément x avec la notation $hash{x}

Scalaire (chaîne & nombre)

Affectation et test

  • my $var = test;
  • my $var = undef; –> my $var; –> undef($var)
  • if(defined($var)); test si $var est définie

Références

Une référence est obtenue par le caractère “\” préfixant la variable.
On accède au contenu de la référence en préfixant la variable par le caractère “$”.

my $var = test;
 
# Création de la référence dans la variable $refvar
$refvar=\$var; 
 
# Affichage de la référence
print "$refvar";
SCALAR(0x9a6b270)
 
# Affichage de la variable pointée par la référence
print "$$refvar";
test

Opérateurs sur les nombres

  • + –> addition
  • - –> soustraction
  • / –> division | int($x/$y) –> division entière
  • * –> multiplication
  • % –> modulo

Opérateurs sur les chaînes

  • . –> concaténation : $var=“bon”.”jour” –> $var=“bonjour”
  • x –> multiplication : $var=“cool”x3 –> $var=“coolcoolcool”
  • lenght($var) –> renvoie la longueur d'une chaîne [ attention au (”) et (') ].
  • chop($var) –> supprime (en modifiant) le dernier caractère de la chaîne. Renvoie le caractère supprimé.
  • chomp($var) –> supprime (en modifiant) le dernier caractère de la chaîne s'il s'agit d'une fin de ligne. Renvoie le nombre de caractère supprimé.
  • reverse($var) –> renvoie la chaîne dans l'ordre inversé.

Opérateurs de test & comparaison (chaîne & nombre)

Contexte numérique chaîne opérateur
ASCII test
égalité == eq
différence != ne
infériorité < lt
supériorité > gt
inf ou égale le
sup ou égale >= ge
comparaison cmp comparaison
et && booléen
ou ||
not !

Les valeurs fausses sont :

  • zero : 0 (numérique), '0' (chaîne), “0” (chaîne)
  • chaîne vide : '', ”“
  • undef

Toutes les autres valeurs sont VRAIES (même “00”)

Opérateur d'affectation

Le signe égale ( = ) ⇒ tout ce qui est à droite sera executé avant l'affection ⇒ se lit de droite vers la gauche.

Permutation

Cette instruction permet de faire une permutation entre deux scalaires.
$a devient $b et $b devient $a !

($a,$b) = ($b,$a) ;

Listes et tableaux

Les passerelles entre listes et tableaux sont nombreuses en Perl !

Liste

  • () est une liste vide
  • (2,-6,'salut',”demain je $var”) est une liste
  • (2..8) est une liste équivalente à (2,3,4,5,6,7,8) –> elle utilise l'opérateur d'intervalle ” .. “.
  • (c..h) est une liste équivalente à (c,d,e,f,g,h) –> elle utilise l'opérateur d'intervalle ” .. “.
  • On peut utiliser des variables avec l'opérateur d'intervalle [ .. ] –> ($start..$end).
  • (3,-6,('salut',”demain je $var”),”du poulet”) –> (3,-6,'salut',”demain je $var”,”du poulet”).
  • On peut utiliser l'opérateur de répétition [ x ] : (2,-6,'salut')x3 –> (2,-6,'salut',2,-6,'salut',2,-6,'salut')
  • Affectation d'une liste par une liste my ($var1,$var2) = ($var1,$var2);
  • Multi-déclaration de scalaire via une liste : my ($var1,$var2) = (3,4);
  • Affectation d'une liste par un tableau my ($var1,$var2) = @tab2;
  • Permutation de scalaires : ($a,$b)=($b,$a)

L'opérateur QW

Il permet de créer facilement une liste de chaînes de caractères. Il est bien adapté à une longue liste !

my @t = ('bonjour', 'les', 'enfants', 'tout', 'va', 'bien', '?');
my @t = qw(bonjour les enfants tous va bien ?);
my @t = qw/bonjour les enfants tous va bien ?/;
Attention : avec QW les ( ” ) et les ( ' ) ne sont pas pris en compte !

Tableau

  • Les indices des tableaux en Perl commencent à 0
  • my @tab est un tableau vide.
  • my @tab = (2,-6) est un tableau initialisé / affecté par une liste.
  • $tab[2] est l'élément d'indice 2 du tableau @tab.
  • $tab[-1] est le dernier élément du tableau @tab. $tab[-2] est l'avant dernier élément du tableau @tab.
  • $#tab est l'indice du dernier élément du tableau @tab. Donc : $tab[-1] est égale à $tab[$#tab]
  • $nb=@tab est égale à $nb=scalar(@t) : donne le nombre d'éléments du tableau @tab
  • Tester l'existence d'un élément : if (exists( $tab[50] )) {…}
  • Tester la valeur d'un élément : if (defined( $tab[50] )) {…}
  • Affectation d'un tableau à un autre @tab1 = @tab2;
  • Liste avec tableau : my($var,@tab) = @tab2;
  • Permutation de valeurs dans un tableau : ($tab1[1],$tab1[5]) = ($tab1[5],$tab1[1])

Références

Une référence est obtenue par le caractère “\” préfixant le tableau.
On accède au contenu de la référence en préfixant la variable par le caractère “@”.

# Déclaration et affectation d'un tableau
my @tab  = (2,-6);
 
# Déclaration d'une référence sur un tableau
$reftab1=\@tab1;
 
# Affectation d'une valeur à l'élément "1" du tableau
$reftab->[1] = "2";
@$reftab[1] = "2";
 
# Taille du tableau
$sizetab = @$reftab;

Table de hachage

  • Permet d'associer une valeur à une clé !
  • Une clé n'existe qu'une seule fois

Affectation

# déclaration et affectation de plusieurs valeurs
my %hash2 = ( "toto"  =>  "Bordeaux",
             "titi"  =>  "Nantes",
             "tata"  =>  "Paris");
 
my %hash; # déclaration d'une table de hachage vide
$hash{toto}="bordeaux"; # affectation d'une valeur à la clé toto

Tests & Boucles

Contexte

Contexte scalaire : IF
Contexte liste : FOREACH

IF

Simple

if ($var == 1)
{ 
   print "$var\n"; 
}
print "$var\n" if( defined($var) );

Complexe

if ($var == 1)
{ 
   print "$var\n"; 
}
else
{
   print "$var est différent de 1";
}
if ($var == 1)
{ 
   print "$var\n"; 
}
elsif ($var == 2)
{
   print "$var est égale à 2";
}
else
{
   print "$var est différent !";
}

Négation d'un test vrai

if (! $var ) {...}
 
# est équivalent à :
 
unless( $var ) {...}

Notation abrégée

$expr ? $result=1 : $result=0 ;
 
# est équivalent à :
 
if ($expr)
{
   $result=1;
} else {
   $result=0;
}

FOR

for( my $j=0; $j<=150; $j+=1 )
{
   print "$j\n";
}

WHILE

my $var = 0;
while( $var <= 20 )
{
   print "$var\n";
   $var+=2;
}

FOREACH

L'instruction foreach est bien adaptée aux listes et tableaux (contexte liste).

Parcourir un tableau

La variable de parcours n'est pas indispensable, elle sera remplacée par la variable spéciale $_.

foreach (@tab) 
{
   print "$_\n";
}

Parcourir un hash

Ici aussi on utilise la variable spéciale $_ puis la fonction keys( )

foreach( keys(%hash))
{
   print("clé : $_, Valeur : $hash{$_} \n");
}

Influencer une boucle

  • next : provoque la fin d'exécution d'un bloc.
  • last : provoque la fin d'une boucle.
  • redo : provoque le redémarrage du bloc.

Fonctions

Déclaration

  • sub définit une fonction
  • Les arguments sont accessibles via le tableau @_.
  • Visibilité : Une variable déclarée dans une fonction est visible uniquement dans la fonction.

sub my_function
{
   my ($var1, $var2, $var3) = @_;
   ...
   return $end;
#  return ($end1, $end2);
#  return @tab;
}

Appel

my $var = my_function(2,4,6);
my @tab = my_function(2,4,6);
my ($var1,$var2) = my_function(2,4,6);

Fichiers

Opération de test sur un fichier

  • -e : teste si le fichier existe

if( -e "/usr/tmp/fichier" ) { print "Le fichier existe\n"; }

  • -f : teste si le fichier est normal.
  • -d : teste si le paramètre est un répertoire.
  • -l : teste si son paramètre est un lien symbolique. Ceci n’exclut pas que -f ou -d renvoient vrai.
  • -r : teste si le programme a le droit de lire le fichier/répertoire/etc passé en paramètre.
  • -w : teste si le programme a le droit d’écrire.
  • -x : teste si le programme a le droit d’exécuter le fichier ou d’accéder au répertoire.
  • -o : teste si le fichier appartient à l’utilisateur qui exécute le programme.
  • -z : teste si le fichier est vide.
  • -s : teste si le fichier est non vide ; en fait cet opérateur renvoie la taille du fichier.

my $taille = -s $file

  • -M : renvoie l’âge en jour du fichier (depuis le début de l’exécution du programme).

Fonction liste de fichier

La fonction glob() permet de renvoyer une liste de fichier. Cette fonction est simplifiée par la notation <>.

@tab = glob(/etc/apache/conf/*.conf’);
@tab = </etc/apache/conf/*.conf>;

Ouvrir un fichier

La fonction open( HANDLE, expression ) permet d'ouvrir un fichier et renvoie une valeur booléenne vrai ou faux.

  • HANDLE est l’identifiant/descripteur du fichier après ouverture ⇒ en majuscules par convention. Les manipulations doivent être effectuées sur le descripteur de fichier !
  • expression est le nom réel du fichier précédé du/des caractère(s) du mode d’ouverture.
Caractère(s) Mode d’ouverture
aucun lecture
< lecture
> écriture (écrasement)
>> écriture (ajout)
+> lecture et écriture (écrasement)
+< lecture et écriture (ajout)

Ouverture du fichier httpd.conf en mode écriture avec ajout + test de la fonction open

if( ! open(FIC,">> httpd.conf") )
{ 
   exit(1);
}

Ouverture du fichier httpd.conf avec test du retours de la fonction open(). La variable $! contient l'erreur système courante.

open(FIC,">>httpd.conf") or die(open: $!");

Lire et écrire dans un fichier texte

Lire une ligne de FIC ⇒ place la ligne dans la variable scalaire $ligne + ” \r

$ligne = <FIC> ;

Lire toutes les lignes de FIC ⇒ place toutes les lignes dans le tableau @tab

@tab = <FIC> ;

Parcourir toutes les lignes d'un fichier

while(defiend( $ligne = <FIC> ) )
 
# Notation simplifiée :
# La variable $_ représente la ligne courante
while( <FIC> )

Fermer un fichier

Il s'agit de fermer un descripteur de fichier

close ( FIC );

Saisie clavier

Dans un scalaire

$a=<STDIN>;
chomp($a);
 
# ou
 
chomp($a=<STDIN>);
La fonction chomp( ) est utilisée pour supprimer le dernier caractère que si c'est un \n.

Dans une liste

chomp($ligne=<STDIN>);
@tab=split(/\s+/,$ligne);
Ici aussi l'utilisation de la fonction chomp( ) est requise.

Modules de base

use strict ;
use english ;

Le module strict permet :

  • Déclaration des variables / tableaus et tables de hash avec my.
  • Une déclaration avec my est visible dans tous les événements du script en dessous de cette déclaration, ainsi que dans les fonctions.

Le module english permet :

  • Un accès aux variables internes à Perl par leur nom long.

Appel de commande système

Dans un scalaire

# Afficher le résultat sur la sortie standard
system("df -f") ;
 
# Récupérer le résultat dans une variable
$disk=`df -h` ;

Les ` ` (backquotes) du Perl sont différentes de ceux du Bash car elle garde le mise en forme. Les \n ne sont pas supprimés !

Dans un tableau

# Récupérer le résultat dans un tableau
open(SORTIE, "df -h |") ;
@tab=<SORTIE> ;
close(SORTIE) ;

Références

 
asr/sys/perl/perl_en_concentre.txt · Dernière modification: 2016/03/29 23:37 (édition externe)
 
Recent changes RSS feed Donate Powered by PHP Valid XHTML 1.0 Valid CSS Driven by DokuWiki