wiki:PerlInitiation

Perl - Initiation

Ce support de cours ainsi que PerlExercices s'adresse à des débutants en Perl, et présente l'essentiel du language ainsi que ses usages les plus classiques.

1. Contexte

Historique

  • Créé en 1987 par Larry Wall, comme outil de traitement de donnée
  • Mantra 1: "Il y a plus d'une façon de le faire."
  • Mantra 2: "Rendre les choses faciles faciles, et les choses difficiles possibles."
  • PERL: Practical Extraction and Report Language (entre autres)
  • perldoc perlhist
  • Aujourd'hui: Perl 5
  • Demain: Perl 5 + Perl 6

Description

  • Un langage interprété (mais compilée à la volée en bytecode)
  • Un langage dynamique, typé
  • Gestion de la mémoire automatique
  • Emprunte beaucoup à divers langages et outils: Lisp, Awk, sed, shell, etc.
  • Peut implémenter divers paradigmes: impératif, fonctionnel, orienté objet, méta-programmation, etc
  • Très large écosystème de modules faciler à intégrés et bien documentés: CPAN
  • Universel: présent sur n'importe quel Unix depuis plus de 20 ans

Les cousins

Langage Licence Historique Actualité Environnement
Perl GPL ou Artistic 1987 5.8.x CPAN, 10.000 modules
Python Python (compatible GPL) 1990 2.4.x Pypi, 1300 packages
Ruby GPL ou Ruby 1995 1.8.x Rubyforge, 1500 projets
PHP PHP4 (incompatible GPL) 1995 4.4.x/5.1.x PEAR, 370 packages

Applications

Les applications en Perl (plus ou moins) connues:

Et d'innombrables et discrets outils qui pullulent sur tous les serveurs Unix de la planète...

2. Installation

Unix

  • Perl est déjà installé ! perl --version
  • Se référer au système de packetage de votre système d'exploitation

Windows

Et votre éditeur favori: vim, Emacs, Eclipse, etc. Notez l'existence d'un IDE spécialisé Perl, écrit en Perl: Padre.

3. Description rapide

  • L'interpréteur (un simple binaire)
  • Invocation d'un script Perl (shebang: #!, ligne de commande)
  • Les modules: Perl et natifs
  • Documentation
    • Générale: perldoc, man
    • Modules: CPAN
    • Livres: suivez le chameau ! (Camel books chez O'Reilly)

4. Premier programme

  • Hello world:
    #!/usr/bin/perl
    
    print "Hello world !\n";
    
  • Expressions, blocs, commentaires
  • Quoting: guillemets, apostrophes
  • Heredocs:
    print <<EOF;
    Hello world !
    Fin du programme.
    EOF
    

5. Les variables (scalaires, listes, hashes)

  • Utilisation d'une variable scalaire:
    $hello = "Hello world !\n";
    print $hello;
    
  • Utilisation d'une liste:
    @hello = ("Hello", "world", "!\n");
    print "$hello[0] $hello[1] $hello[2]";
    print $hello[0]." ".$hello[1]." ".$hello[2];
    print join(" ", @hello);
    
  • Utilisation d'un tableau associatif (hash):
    %hello = (debut => "Hello", milieu => "world", fin => "!\n");
    print "$hello{debut} $hello{milieu} $hello{fin}";
    

Manipulation des scalaires

  • Opérateurs artithmétiques (entiers, flottants et chaînes)
    $a = 42; $b = ($a * 5) + 8;
    
  • Concaténation (chaînes)
    $a = "Hello"; $a = $a . " world"; $a .= " !\n";
    
  • Opérateur de comparaison et booléens
    $nombre = 42;
    $mot = "bonjour";
    if ($nombre == 42) { print "Egalité\n"; }
    print "Egalité\n" if $nombre == 42;
    if ($mot eq 'bonjour') { print "Equivalence\n"; }
    

Manipulation des listes

  • Méthode alternative pour construire une liste:
    @liste = qw/Hello world !\n/;
    @liste = split(/ /, "Hello world !\n");
    
  • Extraire une partie de la liste (voir splice également):
    @extrait = @liste[1..2]; # world, !\n
    
  • Extraire les éléments d'une liste (vers des scalaires):
    ($debut, undef, $fin) = @hello;
    
  • Concaténer les éléments d'une liste (dans un scalaire):
    $phrase = join(' ', @mots);
    
  • Parcourir les éléments d'une liste:
    foreach $mot (@hello) { print "$mot"; }
    foreach (@hello) { print $_; }
    foreach (@hello) { print; }
    print foreach @hello;
    
  • Ajouter un élément à une liste:
    push @liste, 'bonjou';
    
  • Retirer le premier élément de la liste:
    $element = shift @liste;
    
  • Trier une liste:
    @triee = sort @liste;
    @triee = sort { ! $a <=> $b } @liste;
    
  • Filtrer une liste:
    @selection = grep { $_ > 10 } @liste;
    
  • Transformer les éléments d'une liste (vers une autre liste):
    @resultat = map { $_ * 2 } @liste;
    

Manipulation des hashes

  • Obtenir la liste des clés (indices):
    print $hello{$_} foreach keys %hello;
    
  • Vérifier la présence d'une clé:
    print "Présent" if defined $hello{debut};
    

6. Boucles et tests (contrôle du programme)

  • Boucle numérique classique (à la "C"):
    for ($i = 0; $i < 10; $i++) { print "$i\n"; }
    
  • Boucle do/while/until:
    $i = 0;
    while ($i < 10) { print "$i\n"; $i++; }
    do { print "$i\n"; $i++; } until ($i == 10);
    
  • Tests:
    if ($a == 5) { print "\$a vaut 5\n"; }
    elsif ($a == 6) { print "\$a vaut 6\n"; }
    else { print "\$a vaut $a\n"; }
    
  • Contrôle des boucles (voir aussi: continue, redo):
    foreach (@lines) { next if $_ eq ''; print; }
    foreach (@lines) { last if $_ eq ''; print; }
    

7. Gestion des fichiers

  • Numéroter les lignes d'un fichier:
    $line = 0;
    $line++, print "$line $_" while (<STDIN>);
    
  • Ouvrir un fichier explicitement (en lecture):
    open(SOURCE, "<source.txt");
    while (<SOURCE>) { ... }
    close(SOURCE);
    
  • Ouvrir un fichier explicitement (en écriture):
    open(SORTIE, ">sortie.txt");
    print SORTIE "Contenu du fichier ...";
    close(SORTIE);
    
  • Influence de la variable $/ sur <FILE>
  • PerlIO avancé (important sous Windows): binmode, CRLF

8. Fonctions (sous-programmes)

  • Créer une fonction qui accepte 2 paramètres scalaires:
    sub ma_fonction {
      my ($param1, $param2) = @_;
      ...
    }
    
  • Créer une fonction, syntaxe alternative:
    sub ma_fonction {
      my $param1 = shift @_;
      my $param2 = shift @_;
      ...
    }
    
  • Retour explicite, ou par défaut (l'évaluation de la dernière instruction):
    sub ma_fonction {
      return 0 if !@_; 
      ...
      1;
    }
    
  • Appel de la fonction:
    $resultat = ma_fonction("valeur 1", "valeur2");
    

9. Expressions régulières

  • Recherche d'un mot dans la chaîne:
    $a = "Hello world";
    print "Trouvé" if $a =~ m/hello/;
    
  • Recherche d'un mot dans la chaîne (insensible à la casse):
    print "Trouvé" if $a =~ m/hello/i;
    
  • Egalité simple sur toute la chaîne:
    print "Egal" if $a =~ m/^Hello world!$/;
    
  • Extraction d'un nombre:
    print "Premier nombre lu: $1" if /([0-9]+)/;
    print "Premier nombre lu: $1" if /(\d+)/;
    
  • Remplacer un mot par un autre (plusieurs fois si nécessaire):
    $a =~ s/un mot/par un autre/g;
    
  • Règles générales
  • Expressions régulières 'Perl' et 'POSIX' (sed, awk, etc.)

10. Pilotage d'un programme externe

  • Exécution d'un programme (utilise l'entrée et les sorties standard du script):
    my $return_code = system("rsync -avz /src $dst") >> 8;
    my $return_code = system('rsync', '-avz', '/src', $dst) >> 8; # $dst peut contenir des metacaracteres shell (<>&;, etc)
    
  • Exécution et récupération de la sortie standard (utilise la sortie d'erreur du script):
    my $output = `ls -lR /`;
    my $return_code = $? >> 8;
    
  • Exécution d'un programme et pilotage de son entrée standard:
    open(PROG, "|mail -s test test@test.com");
    print PROG "This is the body of an email.\n";
    close(PROG);
    
  • Exécution d'un programme et lecture de sa sortie comme un fichier:
    open(PROG, "find -type d /|");
    print "folder: $_\n" while (<PROG>);
    close(PROG);
    
  • Communication bidirectionnelle avec un programe: perldoc IPC::open2

11. Spécificités Windows

  • Pour invoquer un programme Perl, préférer un appel explicite à l'interpréteur:
    perl myscript.pl
    
    • si vous avez des droits insuffisants, Perl peut s'installer correctement mais ne pas mettre en place l'association entre l'extension de fichier '.pl' et l'interpréteur Perl
    • si vous omettez l'interpréteur, les redirections (entrée et sorties standards) ne fonctionneront pas
  • Utilisez un éditeur qui peut sauvegarder vos scripts au format 'texte Unix'. Par défaut Windows (et la plupart de ses programmes) stocke les retours chariots avec la séquence CRLF. Cette séquence peut perturber vos lit��raux (chaînes en herdocs par ex), et surtout créer une erreur étrange qui empêche de lancer le script sous GNU/Linux (la raison étant que le système cherche l'interpréteur /usr/bin/perl<CR>).
  • Utilisez toujours le '/' (slash) pour les séparateurs de chemin. Windows les accepte sans problème, et vous n'aurez pas de surprise majeure en passant sous Unix. Si vous avez des chemins absolus en dur ("/usr/bin" ou "C:/tmp") en dehors de sections de configuration bien identifiées, alors votre script n'est pas portable et vous aurez des ennuis. Utilisez des chemins relatifs lorsque cela est possible.
  • Les UNC (chemins réseau en 'machine/partage/...') ne fonctionnent pas avec les fonctions standard de gestion de fichiers Perl. Utilisez un lecteur mappée (avec net use).

12. Quelques programmes

  • Le corps d'un programme respectant les canons d'une comande Unix:
    #!/usr/bin/perl -w
    
    # Perl_template, a boilerplate for cool Perl programs.
    # Copyright (C) 2005,2006 Bearstech - http://www.bearstech.com
    #
    # This program is free software; you can redistribute it and/or modify
    # it under the terms of the GNU General Public License as published by
    # the Free Software Foundation; either version 2 of the License, or
    # (at your option) any later version.
    #
    # This program is distributed in the hope that it will be useful,
    # but WITHOUT ANY WARRANTY; without even the implied warranty of
    # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    # GNU General Public License for more details.
    #
    # You should have received a copy of the GNU General Public License
    # along with this program; if not, write to the Free Software
    # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    
    use Getopt::Long;
    use strict;
    
    my $program = "perl_template";
    my $version = "3.1416-beta";
    
    my $opt_help    = 0;
    my $opt_version = 0;
    
    GetOptions(
      'help|h'        => \$opt_help,
      'version|v'     => \$opt_version,
    ) || print_short_help();
    
    print_help() if $opt_help;
    print_version() if $opt_version;
    
    print "You should program something useful here.\n";
    exit(0);
    
    sub print_help {
      print <<EOF;
    This is a template program which does actually nothing.
    
    Usage: $program [options]
    
    Options:
      -h, --help            Display this help and exit
      -v, --version         Display version information and exit
    EOF
      exit 0;
    }
    
    sub print_short_help {
      print STDERR "Try '$program --help' for more information.\n";
      exit 1;
    }
    
    sub print_version {
      print "$program $version - Copyright 2005,2006 Bearstech\n";
      exit 0;
    }
    
    • perl -w
    • use strict
    • Meta-information: nom du programme(!), version, auteur, date, licence
    • Utilisation du module Getopt::Long
    • Documentation
Last modified 7 years ago Last modified on Oct 8, 2010, 4:12:02 PM