Scripts et Programmation

PERL : Mémo pour scripter

Table des matières

Introduction
Rappels de base
Les variables
1. Affectation de variable
Les Opérateurs
Les structures conditionnelles : If
Les opérateurs de comparaison
Les structures conditionnelles Partie 2
Les tableaux
Les structures conditionnelles Partie 3
1. Foreach
Utiliser des arguments au script
1. Avec le tableau des arguments
2. Avec perl -s
Les fonctions
Manipuler des fichiers
Ça match ?
PERL et SQL
Diverses fonctions
1. Switch
2. Le Try Catch
Astuces diverses

Introduction

Je script, je script, mais parfois, j'ai un sacré trou de mémoire ... et je galère à trouver ce que je cherche sur Internet.

Comment on incrémente une variable ? Comment on fait un SI, un POUR ?

Et bien la réponse se trouve ci-dessous !

Rappels de base

Un script se rend exécutable, finit généralement par .pl

Code BASH :

vi script.pl

Code BASH :

chmod +x script.pl

La première ligne indiquant l'interpréteur est :

Code TEXT :

#! /usr/bin/perl

Dans tous mes scripts Perl, j'utilise :

Code BASH :

use strict;
use warnings;

Cela force l'initialisation propre des variables et permet d'être rigoureux dans le code.

Je rappelle aussi que toutes les lignes se terminent par un point-virgule, et que lorsqu'on affiche avec print une variable, il faut penser à effectuer le saut de ligne avec \n :

Code BASH :

print "Bonjour !\n";

Les variables

Affectation de variable

Il faut avant tout déclarer les variables avec my :

Code BASH :

my $a;

Pour mettre dans la variable a la valeur chaîne toto :

Code BASH :

$a="toto"

De la même façon, on peut mettre dans des variables des nombres :

Code BASH :

$a=42

Pour utiliser ces variables, ajouter un $ devant :

Code BASH :

print "$a\n;"
toto

Les Opérateurs

Les opérateurs de calcul

Si on veut faire une addition :

Code BASH :

$a+3

Si on veut faire une soustraction :

Code BASH :

$a-3

Si on veut faire une multiplication :

Code BASH :

$a*3

Si on veut faire une division :

Code BASH :

$a/3

Les opérateurs de chaines

Si on veut concaténer une variable avec une chaine :

Code BASH :

$b." chaine"

L'importance des guillemets

Code BASH :

my $un_fruit = "une pomme";

Code BASH :

print "Hier, j'ai mangé $un_fruit.\n";[/code]
Affichera [b]Hier j'ai mangé une pomme[/b]
[code=bashprint 'Hier, j\'ai mangé $un_fruit.\n';

Affichera Hier j'ai mangé $un_fruit

A noter que pour échapper un caractère c'est le symbole anti-slash.

Assigner, incrémenter, décrémenter

Plutôt que de faire un calcule complexe tel que

Code BASH :

$a=$a+2

on a des raccourcis pour faire des calculs sur la variable elle même :

Pour l'addition :

Code BASH :

$a += 2

Pour la soustraction :

Code BASH :

$a -= 2

Pour la multiplication :

Code BASH :

$a *= 2

Pour la division :

Code BASH :

$a /= 2

Pour incrémenter :

Code BASH :

$a++

Pour décrémenter :

Code BASH :

$a--

La répétition

Code BASH :

print "bla" x 10;

Les structures conditionnelles : If

Le test "Si'" est généralement fait ainsi :

Code BASH :

if (condition) {
    instructions;
}
else
{
    instructions;
}

Il est possible de faire ça en "oneliner" via :

Code BASH :

(condition) ? instruction si vrai : instruction si faux

On peut aussi écrire comme ça une instruction si une condition est réalisée :

Code BASH :

print "La condition est vraie\n" if ( $var eq "ok" );

Pour les exemples, nous avons besoin d'opérateurs de comparaison, voir ci-dessous.

Les opérateurs de comparaison

Comparaison d'entiers

== : est égal à

Code BASH :

if ( $a == $b )

!= : n'est pas égal à

Code BASH :

if ( $a != $b )

> : est plus grand que

Code BASH :

if ( $a > $b )

>= : est plus grand ou égal à

Code BASH :

if ( $a >= $b )

< : est plus petit que

Code BASH :

if ( $a < $b )

<= : est plus petit ou égal à

Code BASH :

if ( $a <= $b )

Comparaison de chaînes

eq : est égal à

Code BASH :

if ( "$a" eq "$b" )

ne : n'est pas égal à

Code BASH :

if ( "$a" ne "$b" )

Ensuite, on peut comparer par ordre alphabétique.

lt : inférieure à (située avant dans l'ordre alphabétique)

Code BASH :

if ( "$a" lt "$b" )

le : inférieure ou égale à (située avant dans l'ordre alphabétique)

Code BASH :

if ( "$a" le "$b" )

gt : supérieure à (située après dans l'ordre alphabétique)

Code BASH :

if ( "$a" gt "$b" )

ge : supérieure ou égale à (située après dans l'ordre alphabétique)

Code BASH :

if ( "$a" ge "$b" )

Opérateurs Logiques

|| : OU logique : (or semble fonctionner)

Code BASH :

((condition1)||(condition2))

&& : ET logique :

Code BASH :

((condition1)&&(condition2))

! : NON logique :

Code BASH :

((condition1)!(condition2))

Les structures conditionnelles Partie 2

If elsif else

Perl n'inclut pas de fonction Switch par défaut (il faut installer le module Switch pour ça).

On peut donc chainer les if avec des elsif :

Code BASH :

if (condition) {
    instructions;
}
elsif (condition) {
    instructions;
}
else (condition) {
    instructions;
}

unless (if inversé)

L'instruction unless est identique au if, c'est juste que ça exécute les instructions si la condition est fausse :

Code BASH :

unless (condition fausse) {
    instructions
}

For

Pour le for ce n'est pas très compliqué :

Code BASH :

for (compteur; condition; pas) {
    instructions
}

Voici un exemple simple :

Code BASH :

for ($i=1; $i<10; $i++) {
    print $i;
}

While

De manière générale, la syntaxe est la suivante :

Code BASH :

while (condition) {
    instructions
}

Voici un exemple :

Until (while inversé)

L'instruction until est identique au while, c'est juste que ça exécute les instructions si la condition est fausse :

Code BASH :

until (condition) {
    instructions
}

Les tableaux

Création

Pour créer un tableau, on utilise le symbole arobase pour le nommer :

Code BASH :

my @noms = ("pim","pam","poum");

Pour remplir un tableau de 1 à 20, on peut utiliser des raccourcis comme :

Code BASH :

@nombres = (1 .. 20);

Appel des valeurs

On peut appeler les éléments par leur numéro d'index (ça commence à zéro) :

Code BASH :

print "$noms[0]";

Ajouter et supprimer des éléments

On a à notre disposition 4 fonctions :

push(@tab, "Valeur") : Ajoute un élément à la fin du tableau
unshift(@tab, "Valeur") : Ajoute un élément au début du tableau
pop(@tab) : Supprime le dernier élément du tableau
shift(@tab) : Supprime le premier élément du tableau

Exemple :

Code BASH :

push(@noms, "adrien");
unshift(@noms, "adeline");
pop(@noms);
shift(@noms);

On peut aussi supprimer un élément bien précis du tableau en fonction de son nom :

Code BASH :

delete $tab[index]

Exemple de suppression du 4ème élément (index 3) :

Code BASH :

delete $noms[3];

Transformer une chaîne en tableau et inversement

Si on a une chaine du style :

Code BASH :

$copains = "Adrien-Adeline-Mathieu-Marie-Nathalie-Elise";

Et qu'on veut créer un tableau d'après ça, on peut utiliser split :

Code BASH :

@tab = split('séparateur', $chaine);

Exemple :

Code BASH :

@noms = split('-',$copains);

Pour revenir à la chaine créée, on utilise join :

Code BASH :

$chaine = join('séparateur',@tab);

Exemple :

Code BASH :

$copains = join('-',@noms);

Le tri

Pour trier le tableau, par ordre alphabétique par exemple, on utilise sort :

Code BASH :

@tab= sort(@tab);

Longueur du tableau

Pour trouver la longueur d'un tableau, soit on peut utiliser le dernier élément du tableau et ajouter 1 :

Code TEXT :

$nb = $#tab + 1

Soit directement avec la variable tableau :

Code BASH :

$nb = @tab;

Si on appelle juste

Code TEXT :

print @tab;

ça affiche tout le tableau !

Les structures conditionnelles Partie 3

Foreach

La boucle foreach permet de parcourir une liste ou un tableau :

Code BASH :

foreach (LISTE) {
    instructions;
}

Exemple :

Code BASH :

foreach (@tableau) {
    print $_;
}

Utiliser des arguments au script

Avec le tableau des arguments

Tous les arguments passés sont récupérés dans le tableau @ARGV.

On peut afficher les arguments de cette manière :

Code BASH :

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

On peut récupérer le nombre d'arguments via

Code BASH :

$nb_args = @ARGV;

Voici comment récupérer les arguments :

Code BASH :

my $arg1 = $ARGV[0]; #premier argument
my $arg2 = $ARGV[1]; #deuxième argument

Ou mieux :

Code BASH :

my ($arg1, $arg2) = @ARGV;

Avec perl -s

Avec la méthode ci-dessus, c'est difficile de gérer les ordres si ce sont des options.

Voici une façon de faire (très rudimentaire mais qui peut être utile).

Prérequis : Appeler le script avec perl -s (Windows) ou #! /usr/bin/perl -s (Linux)

Voici comment déclarer des options :

Code BASH :

our $a; #ARG -a
our $b; #ARG -b
our $c; #ARG -c

Si on appelle le script de cette façon :

Code BASH :

script.pl -a -b=3 -c=adrien

Dans ce cas précis : La variable $a contient 1 , la variable $b contient 3 , la variable $c contient adrien.

Donc :

Si argument est présent, ça vaut 1 sinon, indéfini.

Si argument est présent et à une valeur : ça prend la valeur

Les fonctions

Il est possible de créer des fonctions grâce à "sub".

Il est préférable de les placer de préférence au début du programme (avant de l'appeler).

Code BASH :

sub affiche() {
    print "On affiche du texte depuis la fonction !\n";
}

Pour appeler la fonction dans le script :

Code BASH :

print "On va appeler la fonction affiche() :\n";
&affiche;
print "La fonction affiche a été appelée !\n";

Et si on veut créer une fonction pour laquelle on passe un paramètre et qui retourne quelque chose (ici exemple avec une fonction qui double un nombre) :

Code BASH :

sub doubler() {
    my $nb = $_[0]; #Premier argument du tableau des arguments
    $nb = $nb*2;
    return $nb;
}

Exemple d'utilisation (ce sera plus parlant) :

Code BASH :

print "On va afficher le double de 21 en appelant doubler(21) : ".&doubler(21)."\n";

Manipuler des fichiers

Pour définir un chemin de fichier dans une variable, c'est comme une chaine :

Code BASH :

my $fic='C:\Users\AZ\Desktop\fic.csv';

On va utiliser la fonction open :

Code BASH :

open (HANDLER, MODE, EXPR)

Un HANDLER (traduit littéralement Manieur) c'est une variable un peu spéciale qui représente le fichier qu'on va «manier». Le MODE c'est l'usage qu'on va en faire (lecture, écriture...). L'EXPRession c'est une chaîne qui contient le chemin d'accès au fichier.

On va faire simple avec quelques exemples.

Ouvrir un fichier en lecture seule.

Code BASH :

open ( HANDLER, "<", $fic ); # OU open ( HANDLER, $fic );
while ( <HANDLER> ) {
    chomp; # Supprime le saut de ligne
    print "$_\n";
}
close ( HANDLER );

Ouvrir un fichier en écriture. (Ecrase tout ce qu'il y a dedans et le créé si existe pas)

Code BASH :

open ( HANDLER, ">", $fic );
print HANDLER "Coucou!\n";
close ( HANDLER );

Ouvrir un fichier en écriture. (écrit à la fin si existe et le créé si existe pas)

Code BASH :

open ( HANDLER, ">>", $fic );
print HANDLER "Coucou ajouté!\n";
close ( HANDLER );

Ça match ?

La correspondance, avec match c'est un test un peu plus élaboré. Le match prend en compte des expressions régulières :

Code BASH :

my $var = "Toto";
if ( $var =~ /^T/ )
{
        print "La variable commence par \"T\" ! \n";
}

PERL et SQL

Intro

Je vais faire des exemples avec une base de données test, dont voici la structure :

Code SQL :

CREATE DATABASE test;
CREATE TABLE messages ( id INT(10) NOT NULL AUTO_INCREMENT, txt VARCHAR(64), PRIMARY KEY (id) );
INSERT INTO messages(txt) VALUES ('coucou');

On va avoir besoin des modules DBI et DBD::mysql :

Code BASH :

use DBI;
use DBD::mysql;

Pour définir par exemple ses variables ça se fait dans des chaines classiques :

Code BASH :

my $db="test";
my $dbhost="localhost";
my $dbport="3306";
my $dbuser="root";
my $dbpasswd="root";

On peut déclarer des variables qui nous serviront par la suite :

Code BASH :

my $db_handle;
my $sql;
my $statement;
my $result; 
my $row;
my $txt;

La connexion

Pour se connecter à la base :

Code BASH :

$db_handle = DBI->connect("dbi:mysql:database=$db;host=$dbhost:$dbport;user=$dbuser;password=$dbpasswd");

On peut se permettre aussi de se mettre en l'UTF8 par exemple :

Code BASH :

$statement = $db_handle->prepare("SET NAMES utf8;");
$statement->execute();

SELECT

Je pense que le petit bout de code sera plus parlant :

Code BASH :

$sql = "SELECT * FROM messages";
$statement = $db_handle->prepare($sql);
$statement->execute();
while ( $row = $statement->fetchrow_hashref()) {
    $result = "ID : $row->{id} - Texte : $row->{txt} ";
    print "$result\n";
}

On exécute la requête, et après on affiche chaque ligne retournée par le SELECT.

INSERT

Idem, bout de code parlant :

Code BASH :

$sql = "INSERT INTO messages(txt) VALUES (?)"; # On met des ? à la place des valeurs
$statement = $db_handle->prepare($sql);
$txt = "Wesh ça va?";
$statement->execute($txt); # On passe à execute les arguments

UPDATE

Code BASH :

$sql = "UPDATE messages SET txt='Comment ça va?' WHERE txt='Wesh ça va?'";
$statement = $db_handle->prepare($sql);
$statement->execute();

DELETE

Code BASH :

$sql = "DELETE FROM messages WHERE id>10";
$statement = $db_handle->prepare($sql);
$statement->execute();

La déconnexion

Code BASH :

$statement->finish;
$db_handle->disconnect();

Diverses fonctions

Switch

Le Switch permet d'effectuer une action en fonction d'un cas précis. Cela évite de mettre une infinité de si alors sinonsi alors sinonsi ...

Il faut par contre utiliser le module Switch

Code BASH :

use Switch;

Voici un exemple complet d'utilisation :

Code BASH :

my $var = "Bonjour";
switch($var){
   case 1            { print "La variable vaut 1" }
   case "a"          { print "La variable est a" }
   case [1..10,42]   { print "La variable est dans la liste" }
   case (\@tab)    { print "La variable est dans le tableau" }
   case /\w+/        { print "La variable correspond au pattern WORD" }
   else              { print "Cas par défaut audun cas ci-dessus ne correspond" }
}

Le Try Catch

Le try/Catch bien connu des développeurs permet de gérer une exception en cas d'erreur.

Pour l'utiliser il faut le module Try::Tiny !

Code BASH :

use Try::Tiny;

Voici un exemple où on gère avec une division par zéro :

Code BASH :

try {
    my $err = 5/0;
}
catch {
    print "Erreur Division par 0 impossible !\n";
}; #Bien penser au ;

Astuces diverses

Longueur d'une chaîne

Code BASH :

my $chaine = "coolympique";
my $longueur = length $chaine;
print "La chaine '$chaine' contient $longueur caractères.";

Récupérer une saisie au clavier

Voici un exemple concret :

Code BASH :

print "Comment vous appelez-vous ? ";
my $nom = <>; # Récupération du nom de l'utilisateur
chomp $nom;   # Retrait du saut de ligne
print "Bonjour, $nom !\n";

Test de variable définie

Code BASH :

my $v;
if ( defined $v ) {
    print "La variable \$v est définie !\n";
} else {
    print "La variable \$v n'est pas définie !\n";
}

Voici un exemple simple pour tester l'OS sur lequel le script s'exécute.

Sous Linux on utlise PERL normal, sous Windows on utilise Strawberry Perl.

Code BASH :

use Encode qw(encode decode);
my $os = $^O;
my $msg = "Bonjour à tous ! Est-ce que ça va bien ?";
if ( $os eq "MSWin32")
    {
        print "On utilise PERL sous Windows bouhhhhh !\n";
        $msg = encode( 'cp437' , $msg);
        print "$msg\n";
    }
    else
    {
        print "On utilise PERL sous Linux yeahhhhhh !\n";
        $msg = encode( 'utf-8' , $msg);
        print "$msg\n";
}

Recharger le programme sans le quitter

Voici une astuce pour relancer un programme par lui même :

Code BASH :

exec( $^X, $0);

Générer un nombre aléatoire

Tout simplement avec la fonction rand !

Code BASH :

$rand = int(rand(10));