La vie des huîtres selon saint Larry (soûlant ...).

Aujourd'hui il est sujet d'un livre. Un livre dont le titre est "Perl moderne", tout simplement. Je ne vais pas vous le cacher, si je vous en parle c'est que je connais un des auteurs. Remarquez que c'est peut-être l'occasion de commencer une section recommandations de bouquins.

L'acheter ou pas ?

Alors pourquoi acheter ce livre ? Pour les arguments commerciaux, je vous laisse aller voir le site de l'éditeur. Pour les vraies raisons ...

• parce qu'il fait 450 pages et que c'est beaucoup
• parce qu'il est assez petit pour tenir dans la poche (enfin avec un bon treillis)
• parce que comme moi vous avez appris Perl en lisant du code Perl
• parce que vous ne savez pas qu'il est possible d'écrire du Perl orienté objet

Mais pourquoi je vous déconseillerais d'acheter ce livre ?

• parce que vous aimez Python et que vous voulez considérer les espaces de fin de ligne comme des erreurs de code
• parce que pour vous le seul code lisible c'est du code C façon K&R
• parce que vous êtes Larry Wall et que vous n'allez rien apprendre

Le contenu du livre

La première partie ravira les débutants en Perl qui apprendront que contrairement à la croyance populaire "$^£¨%*" n'est pas un code Perl valide. Remarquez que même moi, qui sais que "Perl '-sp0777i<X+d*lMLa^*lN%0]dsXx++lMlN/dsM0<j]dsj'" est une ligne de commande valide en Perl, j'y ai appris des choses.

Hé oui, le Perl a bien évolué depuis la première version 5. La partie 2 m'a d'ailleurs appris qu'il y avait une nouvelle façon d'écrire de l'objet en Perl. Moi bêtement je pensais que Perl avait fait les choses super bien en n'ajoutant qu'un mot clé "bless" pour devenir orienté objet. Mais en fait non, il paraît qu'il en faut un peu plus pour entrer proprement dans le paradigme objet. Qu'a cela ne tienne, on utilisera Moose, l'héritage, des setter, des getter et du typage.

Ça vous parait compliqué ? Mais pas du tout le livre contient des exemples simple pour chaque mot clé présenté.

Pour résumer cette partie, ce que j'ai découvert de plus utile ce sont les trigger sur propriétés d'un objets et les méthodes pour intercepter d'autres méthodes.

La troisième partie assez classique avec ce qu'on peut trouver dans les bibliothèque Perl pour traiter les données. Elle parle entre autre de l'infernal problème des dates ...

Passons à un chapitre bien plus passionnant pour qui s'y connaît déjà un peu en Perl, POE. Intuitivement j'aurais dit quelque chose comme "Perl orienté évènement", perdu, il s'agit de "Perl Object Environment". En fait c'est un système puissant de gestion d'évènements et d'états. Le but étant de passer à une programmation événementielle. C'est très pratique lorsque vous codez un serveur, d'autant qu'il existe déjà un grand nombre de méthodes existantes qui vous éviteront de réinventer la roue (la POE::Wheel pour ceux qui connaissent).

Enfin la dernière partie traite d'une chose qui sera bien plus utile à ceux qui ne connaissent pas encore bien Perl, le framework web de Perl. Il permet de parser du HTML, de lire des formulaires, de jouer des séquence complètes de requêtes pour vous faire passer pour un navigateur auprès de votre serveur préféré (pensez-y vous qui devez remplir toutes les semaines le même formulaire dans votre boite ...).

Pour conclure, je dirais que c'est un bon bouquin. Dommage qu'il n'y ait pas un petit site depuis lequel on puisse faire copier/coller des exemples du livre. Heureusement, ils sont assez courts en général. Il y a maintenant un site dédié à ce livre et les exemple y sont disponibles au téléchargement

Allez, soyez gentil, achetez-le, si vous en prenez 2000, je vous promet de faire un article par jour !

Si vous avez aimé, il y a aussi :

1. #!/usr/bin/gcc (bis)
2. Le perl complètement inutile
3. Perles

Vous essayez de développer une expression régulière mais vous ne savez pas pourquoi ça ne marche pas ?

Tester une expression

Je vous propose le petit programme suivant qui vous aidera dans la compréhension du fonctionnement de votre regex. Son usage est simple :

./regtest.pl <regex> <chaine>

Exemple :

./regtest.pl "(\d+7)\.1\." "127.127.1.12"
127.127.1.12 : \d+
127.127.1.12 : \d+7
127.127.1.12 : (\d+7)
127.127.1.12 : (\d+7)\.1\.
    127      : $1

Le programme découpe l'expression en éléments syntaxiquement corrects et les applique à la chaine pour voir ce qui matche et le met en évidence. A la fin la liste des groupes qui ont matchés est affiché.

Il est aussi possible de remplacer une des paramètres (la chaine ou la regex) par un '-'. Le programme boucle alors sur l'entrée et vous permet d'entrer une ligne à chaque fois. Vous pouvez donc faire un test en continu. L'avantage et surtout pour les regexp, cela permet de s'affranchir des caractères spéciaux qui pourraient être interprétés par le shell.

Notez que vous aurez besoin de Regexp::Parser qui n'est pas installé par défaut. Pour cela le plus simple est de se connecter en root puis de faire

$ perl -e shell -MCPAN
install Regexp::Parser

Et oula, maintenant plus de problème, vous pouvez tester vos expression régulières facilement !

Comment ca marche ?

En écrivant ce petit programme, voici quelques petites astuces que j'ai utilisé.

Écrire en couleur dans le terminal de façon portable :

use Term::ANSIColor;
print colored("string", 'red');

Parser une expression régulière perl dans une structure lisible (arbre) :

use Regexp::Parser;
my $parser = Regexp::Parser->new;
$parser->parse($reg);

Récupérer 3 parties d'une chaine lors d'un matching :

• $` : avant le match
• $& : tout le match
• $' : après le mach

Récupérer les position des éléments matchés et des groupes dans la chaine en question :

• @- : tableau des positions de début de chaque groupe
• @+ : tableau des positions de fin de chaque groupe

Vous trouverez le code ici.

Si vous avez aimé, il y a aussi :

1. En vrac (14)
2. Soyez réguliers (1)
3. Lignes de commande en sed

Suite à l'article précédent, qui posait les bases des expressions régulières, vous êtes probablement resté sur votre faim. Voici quelques astuces permettant d'élever le niveau et de faire des expressions mieux construites, plus rapides, plus courtes ...

Traitement des lignes

Fonctionnalités que tous les outils ne proposent pas, mais qui sont inclues dans le langage PCRE, /m et /s sont des modificateurs comme dans 's/toto/tata/m'.

Il faut bien distinguer les 2 qui portent assez facilement à confusion. De plus les 2 peuvent être utilisées en même temps.

• /m est utilisé pour changer la syntaxe de '^' et '$' qui habituellement matchent le début et la fin de la chaîne, avec /m ils matcheront le début et la fin de chaque ligne.
• /s est utilisé pour changer la syntaxe de '.' qui habituellement matche n'importe quel caractère sauf le changement de ligne, avec /s il matchera n'importe quel caractère y compris le changement de ligne

Ces modificateurs ne font la différence que lorsqu'on veut toucher aux caractères de retour à la ligne et plus généralement, lorsqu'on manipule des chaînes de caractère multilignes.

Gloutonnerie

L'algorithme de matching est glouton par défaut, ce qui veut dire que l'expression suivante :

/(.*):/

Marchera tous les éléments qui se trouvent avant le dernier ':' dans

root:x:0:0:root:/root:/bin/bash

On peut désactiver la gloutonnerie (greediness) en utilisant ? :

/(.*?):/

Qui du coup ne matchera plus que le premier élément.

Backreference

Il est possible de référencer un élément capturé à l'intérieur d'une expression régulière, ce qui permet de détecter les répétitions.

Exemple pour matcher le début et la fin d'une balise html.

/<(\w+)>.*?</\1>/

Extensions

Un certain nombre d'extensions d'expressions régulières ont été définies et commencent par '(?' on les utilise peu, mais elles sont très pratiques pour optimiser (en complexité comme en vitesse) des expressions régulières.

Match sans capture

(?:regex)

Permet de matcher sans capturer le contenu dans une variable. Pratique pour éviter la complexité liée à la numérotation des parenthèses imbriquées

Lookahead et lookbehind

Il est possible de matcher des éléments "s'ils sont suivis de" (ou "précédés", ou "ne sont pas"). Ceci permet d'écrire des expressions correspondant beaucoup mieux à la description

qu'on en fait, et parfois même d'écrire ce qui était impossible.

# matche "very funny" et "not boring" mais pas "not funny"
/(\w+ )((?<!not )funny|boring)/

Modificateur inline

Il es possible de changer un modificateur temporairement, par exemple pour rendre le matching insensible à la casse sur un seul mot :

# seul toto peut être écrit indifféremment avec des majuscules et des minuscules
/Bonjour (?i)toto(?-i) la moule/

Encore plus

Vous voulez encore plus de fonctionnalités ? Perl 5.10 apporte son lot de nouveautés dans les expressions régulières. Celles sont-ci sont aussi disponibles dans PCRE pour la plupart puisqu'elles en sont inspirées.

Je ne vais pas vous réécrire cet article très bien fait sur le sujet. Ces nouveautés seront surtout utiles pour les utilisateurs avancés.

Si vous avez aimé, il y a aussi :

1. Soyez réguliers (1)
2. Un seul langage pour les scripts
3. Soyez futé avec vos disques

Il arrive régulièrement d'avoir à développer des expressions régulières. Si on excepte grep et sed, la plupart des outils utilisant des expressions régulières sont compatibles perl (en utilisant PCRE). C'est donc un bon point. Apprendre les expression régulières (qu'on peut considérer comme un langage à part entière) ne sera pas perdu même si on change d'outil ou de langage.

Tests

Avant de développer une expression régulière, je vous propose de vous familiariser avec le test de ces expressions. Si vous avec une ligne de commande c'est tout simple, hop un test ligne par ligne :

$ perl -pe 's/expression/########/'
données
a matcher, 
autant que vous voulez
<ctrl-d>

Mais si vous préférez un interface plus évoluée : voici un des nombreux qui permettent de tester vos expressions en direct http://myregexp.com/ et avec coloration des éléments matchés.

Syntaxe de base

Une expression régulière, c'est une chaîne de caractère qui a pour but de repérer des informations dans un texte. Elles sont en général implémentées sous forme d'automates à état finis. Cette méthode est extrêmement efficace et dans la plupart des cas il est très difficile de faire plus rapide.

Cette chaîne peut être utilisée pour chercher des informations dans un texte, mais aussi pour faire des remplacements automatisés. Perl utilise une syntaxe autour des expressions régulières pour préciser comment les utiliser. Celle-ci est souvent reprise par les utilisateurs des PCRE mais ca n'a rien d'obligatoire :

• /expression/ : pour faire des recherches
• s/expression/remplacement/ pour faire du recherche/remplacer
• y/expression/remplacement/ pour faire des substitutions de caractères

y/// est un cas particulier que nous ignorerons.

Chacune de ces chaînes peut être suivie par un modificateur. Le plus utile est /i qui permet de ne pas se soucier de la casse. Exemple : /toto/i matchera ToTo. Le deuxième plus important est /g qui permet de faire le remplacement autant de fois que c'est possible et non pas seulement la première fois que l'expression matche.

Attention, hors perl, il se peut que tout ceci ne soit pas valable, mais cela ne change rien quant à la syntaxe des expressions expliquée ci après.

Syntaxe des expressions

Le principe d'une expression régulière (abrégé en regex) est de matcher des milliers de possibilités sans devoir toutes les écrire. Il ne s'agit donc (quasiment) que de "raccourcis".

Donc commençons par les non-raccourcis :

• () : les parenthèses ont deux fonctions, grouper des éléments entre eux et mémoriser le contenu matché pour le rendre réutilisable par la suite
• | : opérateur OU comme dans "confiture ou nutella ?"

Exemples :

^vive (la confiture|le nutella)$

Maintenant les raccourcis :

• . : n'importe quel caractère
• ^ $ : début et fin de chaîne
• [abf] : a ou b ou f
• [a-m] : a ou b ou ... ou m
• [^a b] : tout sauf a ou espace ou b
• \d : un chiffre
• \w : un caractère alphanumérique
• \W : un caractère non alphanumérique
• \s : un caractère d'espacement
• \S : un caractère de non-espacement
• a? : 0 ou 1 fois a
• b+ : 1 ou plus fois b
• c* : 0 ou plus fois c
• d{3} : 3 fois d
• ...

Il y en a plein d'autres, mais avec celles-ci vous saurez vous débrouiller dans la plupart des situations.

Exemples :

# récupérer le hostname d'un nom de domaine dans $1
(\w+)(\.\w+)*
# récupérer une heure/minute/seconde en début de ligne dans $1, $2 et $3
^(\d\d):(\d\d):(\d\d)\s
# matche une ligne variable="valeur" avec ou sans guillemets et des espaces autorisés
^\s*(\w+)\s*=\s*"?(.*)"?

Après cette petite initiation sans conséquences, vous pouvez aller lire la vraie documentation fournie en manpage avec la documentation perl man perlre.

Si vous avez aimé, il y a aussi :

1. Soyez régulier (2)
2. Un seul langage pour les scripts
3. Trucs et astuces (3)

Quelques trucs et astuces de perlistes en vrac. Pour des vrais astuces de pro régulières, n'hésitez pas à visiter le site des moines de perl.

Initialiser un tableau de chaînes sans avec une syntaxe légère, très lisible quand on n'a que des mots, le séparateur étant les caractères blancs, incluant le retour à la ligne :

@tableau = qw( mot1 mot2 mot3 );

Passer du mode script de quelques lignes au mode développement long. Cela vous oblige à déclarer et initialiser toutes vos variables entre autre :

use strict;

Le debug facile :

use Data::Dumper;
# variable peut être n'importe quoi, toutes les sous-sous parties sont écrites :
print Dumper($variable,\@variable);
print Dumper(\%variable);

L'aide en ligne facile, ça fait tout de suite classe dans un script (format) :

use Pod::Usage;
# imprime le contenu de SYNOPSIS et termine le programme avec un code d'erreur 1
pod2usage(1);
# attention, pod est chatouilleux sur les retours à la ligne avant et après les =

=head1 SYNOPSIS

commande  [-o|--option=<valeur>]

=cut

La page de manuel facile (pas seulement le SYNOPSIS comme précédemment) :

# où fichier.pl est le code précédent
$ pod2man fichier.pl > fichier.1
$ man ./fichier.1

Et le dernier pour la route, le parsing d'options facile, très classe, surtout en combinaison avec pod2usage (format) :

use Getopt::Long;
my $options = {
        option => 'defaut'
};
GetOptions( $options, qw(
        option|o=s
));

Si vous avez aimé, il y a aussi :

1. Un seul langage pour les scripts
2. Expression régulière
3. Le perl complètement inutile