La grammaire et la syntaxe de Perl

Perl a cette différence et cette particularité de n'avoir aucune grammaire et n'etre que très peu sensible à la syntaxe. Cela permet au programmeur de ne pas forcement changer trop ces habitudes par rapport à d'autres langages qu'il peut utiliser, et au débutant de pouvoir progresser petit à petit sans forcement bloquer sur des détails.

Pourtant et malgré les libertés qu'accorde un peu trop facilement Perl, nous allons au sein de ce chapitre fixer un certain nombre de règles relatives. Ces règles sont relatives parce qu'elles ne sont pas indispensables au bon fonctionnement d'un programme, mais elles permettront une meilleure maintenabilité du code. D'un côté vous êtes sur d'avoir un code compréhensible pour toute la communauté des programmeurs en Perl, mais plus généralement, vous êtes sur que même des programmeurs C qui ont peu l'habitude du Perl comprendront et pourront intervenir sur votre code.

La première règle indispensable (nous en avons déjà parlé, mais on ne le dira jamais assez) est l'utilisation du package strict par la commande use strict; en troisième ligne de votre code source. Ce package va vous obliger à déclarer vos variables avant de les utiliser, vous ne pourrez les déclarer qu'une fois et toujours en dehors d'un boucle.

#!/usr/bin/perl

use strict;
if($ARGV[0] ne "")
{
    my $file = $ARGV[0];
}
else
{
    die("Syntax : command.pl file");
}

N'est pas valable parce que vous déclarer une variable à l'intérieur d'une condition. Il faut utiliser la syntaxe suivante :

#!/usr/bin/perl

use strict;
my $file;
if($ARGV[0] ne "")
{
    $file = $ARGV[0];
}
else
{
    die("Syntax : command.pl file");
}

Ou nous avons déclaré la même variable avant de procéder à la condition.

Une autre règle très importante de la programmation en Perl est la vérification des actions. Vous allez ouvrir un fichier et reprendre les informations qu'il contient pour faire un traitement par lot et afficher le résultat. Mais que se passe-t'il si le fichier à ouvrir n'est pas présent la ou le programme s'attend à le trouver, ben il va continuer bon gré mal gré à s'executer, au risque d'apporter un resultat faux. Il est nécessaire de tester que l'ouverture de ce fichier s'est bien déroulé en testant la valeur de retour envoyée par la commande open .

Il y a deux façons de tester cela, la première consiste à utiliser la fonction or :

open(IN,"<$file") or die("Can not read $file $!\n");

C'est sans conteste la plus << Perl >> des fonctions et peut être la moins compréhensible pour les programmeurs d'autres langages. Je préfère sans conteste la forme suivante, peut être plus longue et moins lisible de prime abord mais plus puissante et plus claire si on veut appliquer un traitement d'erreur plus complexe qu'un simple die :

if(open(IN,"<$file"))
{
    # traitement si l'ouverture a reussi
}
else
{
    # traitement si l'ouverture a echoue
}

Cette manière d'écrire les choses présente aussi la possibilité de proposer au programme plusieurs solutions avant d'arriver à l'extrème die grâce à la fonction elsif .

Les commentaires en Perl sont tous précédés par le signe # et vont jusqu'à la fin de la ligne. Il faut documenter son code de manière à ce qu'il soit compris et repris le plus facilement possible, un exemple à suivre sur la manière de document un sous programme :

sub sous_prog # sous_prog prend l'argument $_[0] et renvoie 
              # et renvoie la valeur $_[0]+1

Cela vous permettra de ressortir un maximum d'informations par la simple commande :

~ $cat script.pl | grep #

Ce qui ressortira directement tous les sub du programme et les commentaires qui vont avec.

Lorsque une fonction échoue, elle renvoie un message d'erreur et le place dans la variable $! . Si vous demandez au programme de mourrir suite à l'échec d'une fonction, précisez dans le message d'erreur.

die("Le message d'erreur est $!\n");

À la fin d'une commande, il est indispensable de mettre ; pour préciser à Perl que l'on passe à la commande suivante. Malgré tout, ce ; ne se met pas à la fin d'un boucle ou la simple } suffit à préciser à Perl que l'on sort de la boucle et que l'on rentre dans une nouvelle fonction.

L'appel à un sous programme peut s'effectuer de deux façons, soit en précédant l'appel du signe & de la manière suivante &sous_prog() soit en appelant directement le sous programme sans rien préciser de plus sous_prog() . La première méthode a l'avantage de fonctionner avec Perl version 4 alors que la seconde est typiquement lié à Perl version 5.