perl-patterns

Motifs de développement Perl moderne

Idiomes et bonnes pratiques Perl 5.36+ pour construire des applications robustes et maintenables.

Quand activer

• Écrire du nouveau code ou des modules Perl
• Réviser du code Perl pour vérifier la conformité aux idiomes
• Refactorer du code Perl historique vers les standards modernes
• Concevoir l'architecture de modules Perl
• Migrer du code antérieur à 5.36 vers du Perl moderne

Comment ça fonctionne

Appliquez ces motifs comme un biais vers les valeurs par défaut modernes de Perl 5.36+ : signatures, modules explicites, gestion d'erreurs ciblée et frontières testables. Les exemples ci-dessous sont destinés à être copiés comme points de départ, puis adaptés à l'application, la pile de dépendances et le modèle de déploiement que vous avez sous les yeux.

Principes fondamentaux

1. Utiliser le pragma v5.36

Un seul use v5.36 remplace l'ancien boilerplate et active strict, warnings et les signatures de sous-routines.

# Bien : préambule moderne
use v5.36;

sub greet($name) {
    say "Bonjour, $name!";
}

# Mal : boilerplate historique
use strict;
use warnings;
use feature 'say', 'signatures';
no warnings 'experimental::signatures';

sub greet {
    my ($name) = @_;
    say "Bonjour, $name!";
}

2. Signatures de sous-routines

Utilisez les signatures pour la clarté et la vérification automatique du nombre d'arguments.

use v5.36;

# Bien : signatures avec valeurs par défaut
sub connect_db($host, $port = 5432, $timeout = 30) {
    # $host est obligatoire, les autres ont des valeurs par défaut
    return DBI->connect("dbi:Pg:host=$host;port=$port", undef, undef, {
        RaiseError => 1,
        PrintError => 0,
    });
}

# Bien : paramètre glouton pour arguments variables
sub log_message($level, @details) {
    say "[$level] " . join(' ', @details);
}

# Mal : dépaquetage manuel des arguments
sub connect_db {
    my ($host, $port, $timeout) = @_;
    $port    //= 5432;
    $timeout //= 30;
    # ...
}

3. Sensibilité au contexte

Comprenez le contexte scalaire ou liste — un concept fondamental de Perl.

use v5.36;

my @items = (1, 2, 3, 4, 5);

my @copy  = @items;            # Contexte liste : tous les éléments
my $count = @items;            # Contexte scalaire : nombre (5)
say "Éléments : " . scalar @items; # Forcer le contexte scalaire

4. Déréférencement postfixé

Utilisez la syntaxe de déréférencement postfixé pour la lisibilité avec les structures imbriquées.

use v5.36;

my $data = {
    users => [
        { name => 'Alice', roles => ['admin', 'user'] },
        { name => 'Bob',   roles => ['user'] },
    ],
};

# Bien : déréférencement postfixé
my @users = $data->{users}->@*;
my @roles = $data->{users}[0]{roles}->@*;
my %first = $data->{users}[0]->%*;

# Mal : déréférencement circonfixe (plus difficile à lire dans les chaînes)
my @users = @{ $data->{users} };
my @roles = @{ $data->{users}[0]{roles} };

5. L'opérateur isa (5.32+)

Vérification de type infixe — remplace blessed($o) && $o->isa('X').

use v5.36;
if ($obj isa 'My::Class') { $obj->do_something }

Gestion des erreurs

Motif eval/die

use v5.36;

sub parse_config($path) {
    my $content = eval { path($path)->slurp_utf8 };
    die "Erreur de configuration : $@" if $@;
    return decode_json($content);
}

Try::Tiny (gestion d'exceptions fiable)

use v5.36;
use Try::Tiny;

sub fetch_user($id) {
    my $user = try {
        $db->resultset('User')->find($id)
            // die "Utilisateur $id non trouvé\n";
    }
    catch {
        warn "Échec de la récupération de l'utilisateur $id : $_";
        undef;
    };
    return $user;
}

try/catch natif (5.40+)

use v5.40;

sub divide($x, $y) {
    try {
        die "Division par zéro" if $y == 0;
        return $x / $y;
    }
    catch ($e) {
        warn "Erreur : $e";
        return;
    }
}

POO moderne avec Moo

Préférez Moo pour une POO légère et moderne. Utilisez Moose uniquement lorsque son métaprotocole est nécessaire.

# Bien : classe Moo
package User;
use Moo;
use Types::Standard qw(Str Int ArrayRef);
use namespace::autoclean;

has name  => (is => 'ro', isa => Str, required => 1);
has email => (is => 'ro', isa => Str, required => 1);
has age   => (is => 'ro', isa => Int, default  => sub { 0 });
has roles => (is => 'ro', isa => ArrayRef[Str], default => sub { [] });

sub is_admin($self) {
    return grep { $_ eq 'admin' } $self->roles->@*;
}

sub greet($self) {
    return "Bonjour, je suis " . $self->name;
}

1;

# Utilisation
my $user = User->new(
    name  => 'Alice',
    email => '[email protected]',
    roles => ['admin', 'user'],
);

# Mal : hashref béni (pas de validation, pas d'accesseurs)
package User;
sub new {
    my ($class, %args) = @_;
    return bless \%args, $class;
}
sub name { return $_[0]->{name} }
1;

Rôles Moo

package Role::Serializable;
use Moo::Role;
use JSON::MaybeXS qw(encode_json);
requires 'TO_HASH';
sub to_json($self) { encode_json($self->TO_HASH) }
1;

package User;
use Moo;
with 'Role::Serializable';
has name  => (is => 'ro', required => 1);
has email => (is => 'ro', required => 1);
sub TO_HASH($self) { { name => $self->name, email => $self->email } }
1;

Mot-clé natif class (5.38+, Corinna)

use v5.38;
use feature 'class';
no warnings 'experimental::class';

class Point {
    field $x :param;
    field $y :param;
    method magnitude() { sqrt($x**2 + $y**2) }
}

my $p = Point->new(x => 3, y => 4);
say $p->magnitude;  # 5

Expressions régulières

Captures nommées et indicateur /x

use v5.36;

# Bien : captures nommées avec /x pour la lisibilité
my $log_re = qr{
    ^ (?<timestamp> \d{4}-\d{2}-\d{2} \s \d{2}:\d{2}:\d{2} )
    \s+ \[ (?<level> \w+ ) \]
    \s+ (?<message> .+ ) $
}x;

if ($line =~ $log_re) {
    say "Heure : $+{timestamp}, Niveau : $+{level}";
    say "Message : $+{message}";
}

# Mal : captures positionnelles (difficiles à maintenir)
if ($line =~ /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\s+\[(\w+)\]\s+(.+)$/) {
    say "Heure : $1, Niveau : $2";
}

Motifs précompilés

use v5.36;

# Bien : compiler une fois, utiliser plusieurs fois
my $email_re = qr/^[A-Za-z0-9._%+-]+\@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/;

sub validate_emails(@emails) {
    return grep { $_ =~ $email_re } @emails;
}

Structures de données

Références et accès profond sécurisé

use v5.36;

# Références de hash et de tableau
my $config = {
    database => {
        host => 'localhost',
        port => 5432,
        options => ['utf8', 'sslmode=require'],
    },
};

# Accès profond sécurisé (retourne undef si un niveau manque)
my $port = $config->{database}{port};           # 5432
my $missing = $config->{cache}{host};           # undef, pas d'erreur

# Tranches de hash
my %subset;
@subset{qw(host port)} = @{$config->{database}}{qw(host port)};

# Tranches de tableau
my @first_two = $config->{database}{options}->@[0, 1];

# Boucle multi-variables (expérimental en 5.36, stable en 5.40)
use feature 'for_list';
no warnings 'experimental::for_list';
for my ($key, $val) (%$config) {
    say "$key => $val";
}

Entrées/Sorties de fichiers

Ouverture à trois arguments

use v5.36;

# Bien : ouverture à trois arguments avec autodie (module du cœur, élimine 'or die')
use autodie;

sub read_file($path) {
    open my $fh, '<:encoding(UTF-8)', $path;
    local $/;
    my $content = <$fh>;
    close $fh;
    return $content;
}

# Mal : ouverture à deux arguments (risque d'injection de shell, voir perl-security)
open FH, $path;            # NE JAMAIS faire ça
open FH, "< $path";        # Toujours mauvais — données utilisateur dans la chaîne de mode

Path::Tiny pour les opérations sur fichiers

use v5.36;
use Path::Tiny;

my $file = path('config', 'app.json');
my $content = $file->slurp_utf8;
$file->spew_utf8($new_content);

# Itérer sur un répertoire
for my $child (path('src')->children(qr/\.pl$/)) {
    say $child->basename;
}

Organisation des modules

Structure de projet standard

MyApp/
├── lib/
│   └── MyApp/
│       ├── App.pm           # Module principal
│       ├── Config.pm        # Configuration
│       ├── DB.pm            # Couche base de données
│       └── Util.pm          # Utilitaires
├── bin/
│   └── myapp                # Script d'entrée
├── t/
│   ├── 00-load.t            # Tests de compilation
│   ├── unit/                # Tests unitaires
│   └── integration/         # Tests d'intégration
├── cpanfile                 # Dépendances
├── Makefile.PL              # Système de construction
└── .perlcriticrc            # Configuration de linting

Motifs d'exportation

package MyApp::Util;
use v5.36;
use Exporter 'import';

our @EXPORT_OK   = qw(trim);
our %EXPORT_TAGS = (all => \@EXPORT_OK);

sub trim($str) { $str =~ s/^\s+|\s+$//gr }

1;

Outillage

Configuration perltidy (.perltidyrc)

-i=4        # Indentation de 4 espaces
-l=100      # Longueur de ligne de 100 caractères
-ci=4       # Indentation de continuation
-ce         # else accolé
-bar        # Accolade ouvrante sur la même ligne
-nolq       # Ne pas désindenter les longues chaînes entre guillemets

Configuration perlcritic (.perlcriticrc)

severity = 3
theme = core + pbp + security

[InputOutput::RequireCheckedSyscalls]
functions = :builtins
exclude_functions = say print

[Subroutines::ProhibitExplicitReturnUndef]
severity = 4

[ValuesAndExpressions::ProhibitMagicNumbers]
allowed_values = 0 1 2 -1

Gestion des dépendances (cpanfile + carton)

cpanm App::cpanminus Carton   # Installer les outils
carton install                 # Installer les dépendances depuis cpanfile
carton exec -- perl bin/myapp  # Exécuter avec les dépendances locales

# cpanfile
requires 'Moo', '>= 2.005';
requires 'Path::Tiny';
requires 'JSON::MaybeXS';
requires 'Try::Tiny';

on test => sub {
    requires 'Test2::V0';
    requires 'Test::MockModule';
};

Référence rapide : idiomes Perl modernes

Motif historique	Remplacement moderne
use strict; use warnings;	use v5.36;
my ($x, $y) = @_;	sub foo($x, $y) { ... }
@{ $ref }	$ref->@*
%{ $ref }	$ref->%*
open FH, "< $file"	open my $fh, '<:encoding(UTF-8)', $file
hashref béni	classe Moo avec types
$1, $2, $3	$+{name} (captures nommées)
eval { }; if ($@)	Try::Tiny ou try/catch natif (5.40+)
BEGIN { require Exporter; }	use Exporter 'import';
Opérations manuelles sur fichiers	Path::Tiny
blessed($o) && $o->isa('X')	$o isa 'X' (5.32+)
builtin::true / false	use builtin 'true', 'false'; (5.36+, expérimental)

Anti-patrons

# 1. Ouverture à deux arguments (risque de sécurité)
open FH, $filename;                     # NE JAMAIS

# 2. Syntaxe d'objet indirect (analyse ambiguë)
my $obj = new Foo(bar => 1);            # Mal
my $obj = Foo->new(bar => 1);           # Bien

# 3. Dépendance excessive à $_
map { process($_) } grep { validate($_) } @items;  # Difficile à suivre
my @valid = grep { validate($_) } @items;           # Mieux : décomposer
my @results = map { process($_) } @valid;

# 4. Désactivation de strict refs
no strict 'refs';                        # Presque toujours faux
${"My::Package::$var"} = $value;         # Utiliser un hash à la place

# 5. Variables globales comme configuration
our $TIMEOUT = 30;                       # Mal : variable globale mutable
use constant TIMEOUT => 30;              # Mieux : constante
# Meilleur : attribut Moo avec valeur par défaut

# 6. eval de chaîne pour le chargement de modules
eval "require $module";                  # Mal : risque d'injection de code
eval "use $module";                      # Mal
use Module::Runtime 'require_module';    # Bien : chargement sécurisé de modules
require_module($module);

Souvenez-vous : Le Perl moderne est propre, lisible et sûr. Laissez use v5.36 gérer le boilerplate, utilisez Moo pour les objets et préférez les modules éprouvés du CPAN aux solutions faites maison.