doc.progysm.com

Tutoriel

1ere ligne d'un script perl : #! + compilateur utilisé

#!/usr/bin/perl

ou

#!/usr/bin/env perl

Exécution en ligne de commande

perl nomfichier.pl

ou s'il y a la première ligne du fichier avec le compilateur:
chmod +x nomfichier.pl
./nomfichier.pl

Commentaires : après le signe dièse : #

#Voici un commentaire

Les instructions finissent par un point-virgule : ;

instr;

Utilisation de librairie

use nom_lib; # nom_lib : nom de la librairie
use warnings; # utiliser les avertissements
use strict; # éviter les variables non définies (sans my)

Note : warning, strict, CGI et DBI sont des librairies fréquemment utilisées

Littéraux (chaînes et nombres)

Constante qui ne change pas, écrit à la dure (hard-coded) dans le code.

De type scalaire (scalar), une seule dimension.

Chaîne

Entourée de guillemets simples (sans interpolation, excepté \\ ou \') ou guillemets doubles (avec interpolation).

'test single';
"test double";
"\n"; // nouvelle ligne, pour écrire les deux caractères \n on peut utiliser '\n' ou "\\n".
"\t"; // tabulation

Autres syntaxes (avec interpolation):

qq/changement de ligne\n tabulation \t guillemet simple ' et guillemets double "./;
qq#on peut écrire tous les caractères sauf le dièse#;
qq|on peut écrire tous les caractères sauf la barre verticale|;
qq[on peut utiliser des paires];  
qq(on peut utiliser des paires);  
qq{on peut utiliser des paires};  
qq<on peut utiliser des paires>;

#HEREDOC
#avec délimiteur au début, point-virgule, et le même à la fin (avec changement de ligne).
print<<EOF;
texte
texte
texte
EOF

print<<NIMPORTEQUOI;
texte
texte
texte
NIMPORTEQUOI

Nombres

Entier, négatif, flottant, binaire, octal, hexadécimal.

42;
-42;
42_000_000; // 4200000
42.42;
-42.42;
0b101010;   // binaire 101010, 1*32+1*8+1*2 = 42 en décimal
042;        // octal 42, 4*8+2 = 34 en décimal
0x42;       // hexadécimal 42, 4*16+2 = 66 en décimal
0xFF;       // 255 ou 0xff ou 0xFf, on peut aussi écrire 0xfac, 0xefface

Pour des nombres plus grands, voir le module Math::BigInt et Math::BigFloat

Opérateurs

Arithmétique
2**4  # Exposant, 2 exposant 4 = 16
-2**4 # Exposant, suivi du signe négatif -(2 exposant 4) = -16
-4    # Négatif, moins 4
2 * 2 # Multiplication
5 / 2 # Division = 2.5
7 % 2 # Modulo/reste = 1, car 7/2 = 3*2 + 1
1 + 1 # Somme
1 - 1 # Soustraction

Comparaisons:
1 == 1 # égalité de nombres
1 != 2 # non-égalité de nombres
2 > 1 # plus grand que
1 < 2 # plus petit que
1 >= 1 # plus grand ou égal que
1 <= 1 # plus petit ou égal que
gauche <=> droit # signe de gauche-droit, -1, 0 ou 1
1 <=> 2 # -1 si gauche est plus petit que droit
2 <=> 1 # 1 si gauche est plus grand que droit
1 <=> 1 # 0 si c'est égal

Booléens:
&& and # condition ET/and
|| or  # condition OU/or
!  not  # négation
   xor  # condition OU exclusif
<< left shift (* 2)
>> right shift (/ 2)

Binaire:
&     # and (et) binaire
|     # or  (ou) binaire
^     # xor (ou exclusif) binaire
~     # not (inverse) binaire, opération sur un entier (32 bits ou 64 bits selon l'ordinateur)

Chaîne de caractères
xNOMBRE # répétition de chaînes. "ABC"x2 devient ABCABC
.       # point, concaténation de chaînes de caractères ou chaînes . nombres ou nombres . chaînes

Exemple:
  $p = "allo "."toi";
  $p = "Je t'ai dit : «".$p."»"; // $p est égal à "Je t'ai dit «allo toi»"

# Comparaison à l'aide de la table ASCII, voir la fonction ord()
eq      # est égale
ne      # est différent
gt      # plus grand que 
lt      # plus petit que
ge      # plus grand ou égal que
le      # plus petit ou égal que
cmp     # comparaison -1, 0 ou 1

Expression régulière:
=~
!~

Autres:
Opérateur ternaire: condition?valeurvrai:valeurfaux;
Intervalle (range): ..
                    ...
Virgule           : ,   (construction de liste)
Référence à une variable: \   (exemple $var)
Association clé/valeur: =>
Méthode/propriété d'objet: ->



Précédences:
1. Parenthèse ()
2. ->
3. **
4. ! ~ \
5. =~ !~
6. Multiplication * et Division / et Modulo % et Répétition x
7. Moins (négatif) -
8. Somme + et Soustraction - et Concaténation .
9. Bit shift << >>
10. < > <= >= lt gt le ge
11. == != <=> eq ne cmp
12. &
12. | ^
13. &&
14. ||
15. .. ...
16. ?:
17. , =>
18. not
19. and
20. or xor

Conversion

Conversion automatique

"12 pommes" + 0 # 12, prend les premiers chiffres jusqu'à l'espace
"bla" + 0       # 0,  aucun nombre
"-42 42"    + 0 # -42, prend les premiers chiffres jusqu'à l'espace
"0x40"      + 0 # 0+0, prend les premiers chiffres jusqu'à la lettre x.

Conversion avec des fonctions

Pour des conversions de chaînes vers des nombres, voir les fonctions hex()/oct().

Pour des conversions de caractères vers le nombre ASCII: fonction ord().

Variables

précédé par un signe de dollar : $

Identification

Commence par une lettre (a-z, A-Z ou un souligné _) suivi d'un nombre, lettre ou souligné.

Affectation

Simple: signe égal. variable = valeur

Multiple: signe égal. variable = variable = variable = valeur

my $p = 5; # La valeur de $p est 5.
print $p; # 5
print $p; # 5
$p = "test";
print $p; # test

my $q, $r;
$q = $r = 1;

Opérateur de modification et assignation

variable operateur= variable

$a = 1;
$a += 1;
$a -= 1;

Fonctionne pour **, *, +, -, /, ., %, &, |, ^, <<, >>, && et ||

pré-incrémentation, post-incrémentation, pré-décrémentation, post-décrémentation

$a++;
++$a;
$a--;
--$a;

Interpolation

my $abc = 123;
print "ABC = $abc";
print "ABC = ${abc}";

Variable par défaut

$_ est la variable par défaut, elle n'est pas assigné par défaut. Elle est envoyée à toutes les fonctions sans arguments.

$_ = 123;
print; # affiche 123
print $_; # affiche 123
print ""; # n'affiche rien

Portée (scope)

my déclare une variable dans une portée de bloc {}. my ou our est nécessaire si on utilise use strict;

my $f = 1;
print $f; # 1
{ # crée une nouvelle portée pour "my"
  my $f = 2;
  print $f; # 2
  {
    print $f; # 2
  }
}
print $f; # 1

Tableau :
précédé par un Arobas : @
@tab = ('val1', 'val2'[, ...]);

Accès à un élément d'un tableau
$tab[indice];
 indice : premier élément = 0
 $#tab : dernier indice d'un tableau

Fonction
Appel  : [$val_retour = ]nomFonction[([val1[, ...]])];
Exemple:
 fonction;
 fonction();
 $p=fonction();
 $p=fonction($arg1, "arg2");

Entête de fonction
sub nomFonction() {
# Les paramètres sont dans le tableau @_
# les paramètres sont aussi dans la variable $_
# si j'envoie : $res->{NAME} je le met dans un tableau      ???????
# comme ceci : @nom_champs =  @{$_[0]}                      ???????
# $_[0] indique le premier parametres
# @{$valeur} conversion d'une $valeur en @tableau 

 [return (valeur);]

}

Fonction perl:
On peut appelé deux instructions si la première est nulle avec le mot-clé "Or"
Syntaxe : nomFonction() or instruct;

 die "chaine";
  Fin du fichier et affiche le message "chaine"

 val = length(chaine);
  chaine : chaîne dont on veut connaître la longueur
  val    : longueur de la chaîne
  
 print chaine;
  chaîne peut être une chaîne de forme                 : "chaine"
         peut être une chaîne renvoyé par une fonction : nomFonction($arg)
         peut être une variable                        : $chaine
         
 $chaine2 = substr(chaine1, depart, fin) ;
  chaine1 : chaine dont on veut une partie
  depart  : position de debut de la sous-chaine (premier caractères à la position 0)
  fin     : fin de la sous-chaine
  chaine2 : chaine resultante

Nouvel objet : $p = new CGI; # crée un nouvel objet CGI nommé $p.
Accès à un élément d'un objet
$p->fonction()

===============
Objet CGI;
Fonctions:
$p = new CGI;

$p->end_html();       # est égal à </BODY></HTML>
$p->h1([chaine])      # est égal à <H1>chaine</H1>
    chaine : chaine de caractères comprises entre la balise <h1></h1>
$p->header();         # est égal à Content-type ... : \n\n
$p->start_html();     # est égal à <HTML><BODY>
$p->param('chaine')   # permet d'accéder à la valeur d'un champ 'chaine' (envoyer 
                        par l'adresse)
                       
                        Exemple : fichier.pl?nom=monNom;
                        $p->param('nom') est égal à "monNom";

===============
Fonction DBI;
Fonctions:
$retourConnexion = DBI->connect(type_basedonnee, nomUtilisateur, [autre]);

$retourConnexion : pointeur retourné après la connexion
type_basedonnee: Chaîne de caractères définissant le type de base de données et 
                 le nom de la base de données.
                 Exemple : "dbi:Pg:dbname=root" 
                            dbi:Pg             #type de base Postgres
                            dbname=root        #nom de la base est root
nomUtilisateur: Nom d'utilisateur de la base de données
[autre]       : ???

Objets:
$retourConnexion:
 Fonctions:

 $retourConnexion->prepare(commande_sql);
  Préparation d'une commande SQL
  commande_sql : Est une chaine de caractère contenant une commande SQL
                 Ex: $retourPrepare->prepare("insert into nomTable ("numero, nom") values ('1', 'monNom')"); 

$retourPrepare:
  Fonctions:
  $retourPrepare->execute();
   Exécution d'une commande SQL (déjà préparer)

   @tableau = $retourPrepare->fetchrow();
   Renvoie les valeurs retournées par une requêtes SQL dans un tableau.

   $retourNAME = $retourPrepare{NAME}
   $retourNAME représente les titres des champs.
   
   
Variables:
$DBI::errstr; // erreur lors d'un accès à une base de données.


==========
Condition

Comparaison 
chaine1 eq chaine2 : test l'égalité entre deux chaîne

Condition
if ( condition ) { 
 instruction;
}
[ else {} ]

instruction1 or instruction2; si instruction1 est faux, instruction2 est exécuté.

Boucles:

foreach(@tableau) {};
 @tableau représente un tableau d'élément.
          chaque élément du tableau à chaque tour peut être accédé
          par la variable "$_"
 Exemple:
  foreach(@tableauNote) {
   print "Note : $_";
  }
  
foreach(valeur..valeur2) {};
# la valeur rendu est stocké dans la variable "$_"

foreach (0..5) {
 print $_;
 # $_[$_ + 1] ?????
}
sub aff_entete_champs()
{	
    @nom_champs =  @{$_[0]} ;	#caster le param en tableau
    foreach (@nom_champs){
	print "<td><b>$_</b>";
}


  return ( );
}

sub envoyer_formulaire(){
    @nom_champs =  @{$_[0]} ;	#caster le param en tableau
    @contenu	=  $_[1] ;
    print '<form method="post" action="script.pl">'."\n";
    print '<table border="1" summary="liste de champs">';
    foreach (0..$#nom_champs){	
	print "<tr><td>".$nom_champs[$_]. " ";
	print "<td><input type=\"text\" name=\"$nom_champs[$_]\" value=\" $_[$_ + 1]\"></td>";    
	print '</tr>';
    }
    print '</table>';
    print '<input type="submit" name="bouton" value="Confirmer">';
    print '</form>';
}

Structure de données

Les tableaux

Un tableau est une liste d'élément qui commence à l'indice 0 et se termine à $#tableau.

Le tableau est dynamique et on peut affecter une valeur à n'importe quel indice plus grand ou égale à 0.

La grandeur du tableau est délimité par l'indice le plus grand. C'est à dire que les éléments intermédiaires sont égales à une chaine vide, n'existes pas et ne sont pas définis (exists($tableau[$indice])) retourne false et defined($tableau[$indice]) return false lorsqu'ils sont créer automatiquement sans affectation.

Déclaration: my @tableau = ();

Déclaration et initialisation: my @tableau = (1,2,3); my @tableau2 = ("a",2,"b");

Affectation: $tableau[0] = 1;

Ajout d'un élément à la fin: push(@tableau, $element);

Utilisation d'un élément: $tableau[0]

Nombre d'élément: scalar(@tableau) ou ($#tableau + 1)

Indice maximum: $#tableau (retourne -1 si le tableau est vide)

Affichage: print $tableau; (affiche tous les éléments à la suite de l'autre sans séparateur)

Affichage des éléments de l'indice 0 à $#tableau s'il y a des éléments avec une boucle foreach:
foreach(@tableau) { print $_; }
foreach my $value (@tableau) { print $value; }
(si un indice intermédiaire n'existe pas, une chaîne vide sera affiché).

Affichages des éléments pour les indices 0 à $#tableau s'il y a des éléments avec un séparateur: print join(',', @tableau);

Affichages des éléments avec affectation non undef, for (my $i = 0; $i <= $#tableau; $i++) { print $tableau[$i] if defined $tableau[$i]; }

Effacer un indice: delete $tableau[0];. La taille du tableau change seulement s'il s'agit du dernier indice.

Autres exemples:

my @tableau = (); # la taille du tableau, scalar(@tableau), est 0, l'indice maximum est -1 ($#tableau)
$tableau[0] = "a";  # la taille du tableau, scalar(@tableau), est 1, l'indice maximum est 0 ($#tableau)
$tableau[3] = "b";  # la taille du tableau, scalar(@tableau), est 4, l'indice maximum est 3 ($#tableau). 
                    # Les éléments [1] et [2] n'existe pas (!exists), ne sont pas définis (!defined) et sont égaux à la chaine vide '' 
                    # !exists($tableau[1]) && !defined($tableau[1]) && $tableau[1] == '' && $tableau[1] == 0  tous vrai.
$tableau[1] = 1;
delete($tableau[1]); # L'élément [1] n'existe pas, n'est pas défini, est égal à '', est égal à 0 et l'indice maximum est 3.
                     # !exists($tableau[1]) && !defined($tableau[1]) && $tableau[1] == '' && $tableau[1] == 0 && $#tableau == 3
$tableau[2] = undef; # L'élément [2] existe, n'est pas défini, est égal à '', est égal à 0 et l'indice maximum est 3.
                     # exists($tableau[2]) && !defined($tableau[2]) && $tableau[1] == '' && $tableau[1] == 0 && $#tableau == 3

Entrée/sortie

print envoie à la sortie standard (STDOUT).

<STDIN> demande et retourne une ligne à l'entrée standard.

$my line = <STDIN>;
print "your line: $line\n";

Ligne de commande

Pour faire un grep des numéros en fin de ligne:

echo "chaine avec un numéro a la fin 1234" | perl -ne 'print "$1" if /(\d+)$/'
num=`echo "chaine avec un numéro a la fin 1234" | perl -ne 'print "$1" if /(\d+)$/'`;
echo $num

Intégration perl/apache

dans un fichier de configuration d'apache, ajouter: Options ExecCGI dans un <Directory>