Impatient Perl

Sommaire

1. Particularites
2. Le fichier
3. Les types de variables
4. Utilisation de variables
5. Variables particulieres
6. Operateurs et mots-cles
7. Les fonctions
8. Exemple
9. Manipulation de fichiers

Particularites

• Adapte a la manipulation de strings et de fichiers.
• Se lance avec "perl fichier.pl" ou "./fichier.pl" avec les droits d'execution sur le fichier (755).
• Pas de pre-compilation. Le code est interprete pendant l'execution.
• Perl commence par lire le script puis l'execute apres. On peut donc declarer des fonctions apres les avoir appelees.

Le fichier

• Extension ".pl".
• Pas d'indentation particuliere (ne pas confondre avec Python)
• Premiere ligne :

  
        #!/usr/local/bin/perl -w
      

  (a adapter en fonction de l'emplacement de perl)
• Il est conseille de mettre ces lignes en debut de fichier :
  

  
        use warnings;
        use strict;
      

  Elles permettent de loader des modules qui affichent des Warnings en cas de problemes.
• Les lignes de commentaires commencent par un "#"

Les types de variables

• Leurs noms ne doivent contenir que des chiffres, des lettres et des underscore ("_"). Ils ne doivent pas commencer par un chiffre.
• Les variables scalaires commencent par un "$".
  Elles peuvent etre des nombres :
  - En decimal 42,
  - En octal 052,
  - En hexadecimal 0x2A
  - En flottant 42.0
  Ou des chaines de caracteres :
  - "ma chaine de caracteres entourees de guillemets."
• Les variables tableaux commencent par un "@".
  Elles correspondent a des tableaux de variables.
• Les variables hash commencent par un "%".
  Elles correspondent a des tableaux de type "cles" -> "valeur".
• Les variables anonymes commencent par un "$".
  Elles correspondent a des "pointeurs" vers des variable sans nom.

Utilisation de variables

• On declare et on initialise une variable grace a my :
  

  
        my $ma_variable = 42;
        my $ma_chaine_de_caracteres = "le pays du 42";
        my @mon_tableau = (1, "deux", 3.0);
        my %mon_tableau_hash = ("nom" => "toto", "age" => 42, "adresse" => "le pays du 42");
  
        my $mon_pointeur_vers_ma_variable = \$ma_variable;
        my $mon_pointeur_vers_scalar_anonyme = \42;
        my $je_donne_un_nom_au_scalar_anonyme = ${$mon_pointeur_vers_scalar_anonyme};
        my $mon_pointeur_vers_tableau_anonyme = ["quatre", 5.0, 6];
        my @je_donne_un_nom_au_tableau_anonyme = @{$mon_pointeur_vers_tableau_anonyme};
        my $mon_pointeur_vers_hash_anonyme = { "nom" => "tata", "age" => 21, "adresse" => "le pays du 42/2" };
        my %je_donne_un_nom_au_hash_anonyme = %{$mon_pointeur_vers_hash_anonyme};
      

• On affiche des variables grace a print ou Dumper :
  

  
        print "ma_variable             : $ma_variable\n";
        print "ma_chaine_de_caracteres : $ma_chaine_de_caracteres\n";
        print "mon_tableau             : @mon_tableau\n";
        
        print Dumper($ma_variable);
        print Dumper($ma_chaine_de_caracteres);
        print Dumper(@mon_tableau);
        print Dumper(%mon_tableau_hash);
        

Variables particulieres

• On recupere les arguments passes en ligne de commande avec le tableau @ARGV.
  Le premier element du tableau, @ARGV[0], n'est pas le nom de la commande mais bien le premier argument.
• On recuper le nombre d'arguments passes en ligne de commande avec $#ARGV.
  C'est egal a -1 s'il n'y a pas d'arguments, 0 s'il y en a un, etc.
• Le nom du script est dans $0 ou $^X.
• On recupere le PID grace a $$.
• La variable courant est dans $_.
  Elle sert par exemple dans des boucles while, des fonctions, des eval, etc.
• La derniere erreur qui s'est produite se trouve dans $!.
  C'est a la fois le numero de l'erreur et le message d'erreur selon la maniere dont il est utilise.
• On peut recuperer les variables d'environnement dans le tableau de hash %ENV.
• On recupere le nom du systeme d'exploitation (MSWin32, linux ou darwin) grace a $^O
• On utilise les signaux grace au tableau de hash %SIG (man perlipc(1)).

Operateurs et mots-cles

• Calculs, bits : + - * / = & | ^ >> << >>>
• Comparaison, logique : == < <= > >= != || && !
• Comparaison de strings :
  - concatenation : .
  - egal : eq (==)
  - inferieur : lt (<)
  - inferieur/egal : le (<=)
  - superieur : gt (>)
  - superieur/egal : ge (>=)
  - different : ne (!=)
  
• Mots-cles :
  - if elsif else :
  si (condition) {action}
  ou si (condition) {action}
  sinon {action}
  - ternaire : (condition) ? si vrai : sinon;
  - unless : si la condition est fausse (= if (!(condition)))
  - while : boucle "tant que" (condition)
  - for : boucle avec compteur (compteur; condition; modification du compteur)
  - until : boucle avec condition fausse (= while (!(condition)))
  - foreach $nom_elem (@liste) : parcours une liste (par exemple un tableau) et fais l'action indiquee pour chaque element. L'element est alors dans nom_elem.
  - next; : instruction dans une boucle indiquant de passer directement au suivant.
  - last; : instruction arretant une boucle.
  

Les fonctions

• S'appellent avec &

  
        &ma_fonction_sans_argument;
        &ma_fonction_avec_un_argument($argument);
        &ma_fonction_avec_plusieurs_arguments($arg1, $arg2, $arg3);
      

• Se declarent avec sub.
• Quand il n'y a qu'un argument, il se trouve dans la variable $_ (ou @_ si c'est un tableau, etc.)
• S'il y en a plusieurs, ils sont dans un tableau @_.
• On accede aux elements d'un tableau avec @_[1], @_[2], @_[3],...
• Exemple :
  

  
        sub ma_fonction_sans_argument
        {
          print "coucou\n";
        }
        sub ma_fonction_avec_un_argument
        {
          print $_."\n";
        }
        sub ma_fonction_avec_plusieurs_arguments
        {
          if (@_[1] < @_[2])
          {
  	  return @_[3];
  	}
  	else
  	{
  	  foreach $elem (@_)
            {
              print $elem."\n";
            }
          }
  	return @_[1];
         }
  

Exemple

  my $variable_trop_cool = 0;
  
  &une_super_fonction($variable_trop_cool);
  
  sub une_super_fonction
  {
    while ($_ < 6)
    {
        if ($_ == 0)
        {
            print  "je suis dans le if\n";
        }
        elsif ($_ == 1)
        {
            print  "je suis dans le elsif\n";
        }
        elsif ($_ == 2)
        {
            $_ += 2;
            next;
        }
        else
        {
            print  "je suis dans le else\n";
        }
        unless ($_ > 3)
        {
            print "je ne suis pas superieur a 3\n";
        }
        print $_." prochain tour de boucle\n";
        $_++;
    }
  }
  

Manipulation de fichiers

• STDIN et STDOUT sont l'entree et la sortie standard.
• open(FILEHANDLER, chemin_du_fichier) ouvre ou creer des fichiers.
  - le filehandler contient les lignes lues dans le fichier. Il n'a pas de caractere pour designer son type donc on le met en general en majuscule.
  - le chemin_du_fichier peut etre precede d'un > s'il doit etre creer, d'un >> si on peut ecrire dedans. S'il n'a pas de signe particulier, c'est une lecture seule.
• Cette fonction (et d'autres) peut echouer. On peut alors quitter avec die.
• close(FILEHANDLER); s'appelle une fois l'utilisation du fichier terminee.
• Exemple :

  
        open(FICHIER1, "mon_fichier.txt") or die "pas reussi a ouvrir le fichier...";
        while ()
  	{
  	  print "j'ai lu la ligne :  $_\n";
  	}
  	close(FICHIER1);
  	open(FICHIER2, ">mon_nouveau_fichier.txt") or die "pas reussi a creer le fichier...";
  	my $i = 0;
  	for($i = 0; $i < 5; $i++)
  	{
  	  print FICHIER2 "coucou ligne".$i."\n";
  	}
  	close(FICHIER2);