perl-patterns

Moderne Perl-Entwicklungsmuster

Idiomatische Perl 5.36+ Muster und Best Practices für den Bau robuster, wartbarer Anwendungen.

Wann aktivieren

• Beim Schreiben von neuem Perl-Code oder Modulen
• Beim Überprüfen von Perl-Code auf Idiom-Konformität
• Beim Refactoring von Legacy-Perl auf moderne Standards
• Beim Entwurf der Perl-Modul-Architektur
• Beim Migrieren von Code vor 5.36 zu modernem Perl

Funktionsweise

Wenden Sie diese Muster als Voreinstellung für moderne Perl 5.36+ Standardeinstellungen an: Signaturen, explizite Module, fokussierte Fehlerbehandlung und testbare Grenzen. Die folgenden Beispiele sollen als Ausgangspunkte kopiert und dann für die tatsächliche Anwendung, den Abhängigkeitsstapel und das Bereitstellungsmodell angepasst werden.

Kernprinzipien

1. Das v5.36 Pragma verwenden

Ein einzelnes use v5.36 ersetzt den alten Boilerplate-Code und aktiviert strict, warnings und Subroutinen-Signaturen.

# Gut: Moderner Vorspann
use v5.36;

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

# Schlecht: Legacy-Boilerplate
use strict;
use warnings;
use feature 'say', 'signatures';
no warnings 'experimental::signatures';

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

2. Subroutinen-Signaturen

Verwenden Sie Signaturen für Klarheit und automatische Überprüfung der Argumentanzahl.

use v5.36;

# Gut: Signaturen mit Standardwerten
sub connect_db($host, $port = 5432, $timeout = 30) {
    # $host ist erforderlich, andere haben Standardwerte
    return DBI->connect("dbi:Pg:host=$host;port=$port", undef, undef, {
        RaiseError => 1,
        PrintError => 0,
    });
}

# Gut: Slurpy-Parameter für variable Argumente
sub log_message($level, @details) {
    say "[$level] " . join(' ', @details);
}

# Schlecht: Manuelles Auspacken der Argumente
sub connect_db {
    my ($host, $port, $timeout) = @_;
    $port    //= 5432;
    $timeout //= 30;
    # ...
}

3. Kontextsensitivität

Verstehen Sie skalaren vs. Listenkontext – ein zentrales Perl-Konzept.

use v5.36;

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

my @copy  = @items;            # Listenkontext: alle Elemente
my $count = @items;            # Skalarer Kontext: Anzahl (5)
say "Artikel: " . scalar @items; # Erzwingen des skalaren Kontexts

4. Postfix-Dereferenzierung

Verwenden Sie die Postfix-Dereferenzierungssyntax für bessere Lesbarkeit bei verschachtelten Strukturen.

use v5.36;

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

# Gut: Postfix-Dereferenzierung
my @users = $data->{users}->@*;
my @roles = $data->{users}[0]{roles}->@*;
my %first = $data->{users}[0]->%*;

# Schlecht: Circumfix-Dereferenzierung (schwerer lesbar in Verkettungen)
my @users = @{ $data->{users} };
my @roles = @{ $data->{users}[0]{roles} };

5. Der isa-Operator (5.32+)

Infix-Typenprüfung – ersetzt blessed($o) && $o->isa('X').

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

Fehlerbehandlung

eval/die-Muster

use v5.36;

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

Try::Tiny (Zuverlässige Ausnahmebehandlung)

use v5.36;
use Try::Tiny;

sub fetch_user($id) {
    my $user = try {
        $db->resultset('User')->find($id)
            // die "Benutzer $id nicht gefunden\n";
    }
    catch {
        warn "Fehler beim Abrufen des Benutzers $id: $_";
        undef;
    };
    return $user;
}

Nativer try/catch (5.40+)

use v5.40;

sub divide($x, $y) {
    try {
        die "Division durch Null" if $y == 0;
        return $x / $y;
    }
    catch ($e) {
        warn "Fehler: $e";
        return;
    }
}

Modernes OO mit Moo

Bevorzugen Sie Moo für leichtgewichtiges, modernes OO. Verwenden Sie Moose nur, wenn sein Metaprotokoll benötigt wird.

# Gut: Moo-Klasse
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 "Hallo, ich bin " . $self->name;
}

1;

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

# Schlecht: Blessed Hashref (keine Validierung, keine Accessoren)
package User;
sub new {
    my ($class, %args) = @_;
    return bless \%args, $class;
}
sub name { return $_[0]->{name} }
1;

Moo-Rollen

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;

Nativer class-Schlüsselwort (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

Reguläre Ausdrücke

Benannte Captures und /x-Flag

use v5.36;

# Gut: Benannte Captures mit /x für Lesbarkeit
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 "Zeit: $+{timestamp}, Ebene: $+{level}";
    say "Nachricht: $+{message}";
}

# Schlecht: Positionelle Captures (schwer zu warten)
if ($line =~ /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\s+\[(\w+)\]\s+(.+)$/) {
    say "Zeit: $1, Ebene: $2";
}

Vorkompilierte Muster

use v5.36;

# Gut: Einmal kompilieren, oft verwenden
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;
}

Datenstrukturen

Referenzen und sicherer tiefer Zugriff

use v5.36;

# Hash- und Array-Referenzen
my $config = {
    database => {
        host => 'localhost',
        port => 5432,
        options => ['utf8', 'sslmode=require'],
    },
};

# Sicherer tiefer Zugriff (gibt undef zurück, wenn eine Ebene fehlt)
my $port = $config->{database}{port};           # 5432
my $missing = $config->{cache}{host};           # undef, kein Fehler

# Hash-Slices
my %subset;
@subset{qw(host port)} = @{$config->{database}}{qw(host port)};

# Array-Slices
my @first_two = $config->{database}{options}->@[0, 1];

# Multi-Variable-for-Schleife (experimentell in 5.36, stabil in 5.40)
use feature 'for_list';
no warnings 'experimental::for_list';
for my ($key, $val) (%$config) {
    say "$key => $val";
}

Datei-I/O

Drei-Argumente-Open

use v5.36;

# Gut: Drei-Argumente-Open mit autodie (Kernmodul, eliminiert 'or die')
use autodie;

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

# Schlecht: Zwei-Argumente-Open (Shell-Injection-Risiko, siehe perl-security)
open FH, $path;            # NIEMALS so machen
open FH, "< $path";        # Immer noch schlecht – Benutzerdaten im Modus-String

Path::Tiny für Dateioperationen

use v5.36;
use Path::Tiny;

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

# Verzeichnis durchlaufen
for my $child (path('src')->children(qr/\.pl$/)) {
    say $child->basename;
}

Modulorganisation

Standard-Projektstruktur

MyApp/
├── lib/
│   └── MyApp/
│       ├── App.pm           # Hauptmodul
│       ├── Config.pm        # Konfiguration
│       ├── DB.pm            # Datenbankschicht
│       └── Util.pm          # Hilfsfunktionen
├── bin/
│   └── myapp                # Einstiegspunkt-Skript
├── t/
│   ├── 00-load.t            # Kompilierungstests
│   ├── unit/                # Unit-Tests
│   └── integration/         # Integrationstests
├── cpanfile                 # Abhängigkeiten
├── Makefile.PL              # Build-System
└── .perlcriticrc            # Linting-Konfiguration

Exporter-Muster

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;

Werkzeuge

perltidy-Konfiguration (.perltidyrc)

-i=4        # 4 Leerzeichen Einzug
-l=100      # 100 Zeichen Zeilenlänge
-ci=4       # Fortsetzungseinzug
-ce         # Geschmiegtes else
-bar        # Öffnende Klammer in derselben Zeile
-nolq       # Lange Strings nicht einrücken

perlcritic-Konfiguration (.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

Abhängigkeitsverwaltung (cpanfile + carton)

cpanm App::cpanminus Carton   # Werkzeuge installieren
carton install                 # Abhängigkeiten aus cpanfile installieren
carton exec -- perl bin/myapp  # Mit lokalen Abhängigkeiten ausführen

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

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

Kurzreferenz: Moderne Perl-Idiome

Legacy-Muster	Moderne Entsprechung
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
blessed hashref	Moo-Klasse mit Typen
$1, $2, $3	$+{name} (benannte Captures)
eval { }; if ($@)	Try::Tiny oder nativer try/catch (5.40+)
BEGIN { require Exporter; }	use Exporter 'import';
Manuelle Dateioperationen	Path::Tiny
blessed($o) && $o->isa('X')	$o isa 'X' (5.32+)
builtin::true / false	use builtin 'true', 'false'; (5.36+, experimentell)

Anti-Patterns

# 1. Zwei-Argumente-Open (Sicherheitsrisiko)
open FH, $filename;                     # NIEMALS

# 2. Indirekte Objektsyntax (mehrdeutige Analyse)
my $obj = new Foo(bar => 1);            # Schlecht
my $obj = Foo->new(bar => 1);           # Gut

# 3. Übermäßiges Vertrauen auf $_
map { process($_) } grep { validate($_) } @items;  # Schwer zu folgen
my @valid = grep { validate($_) } @items;           # Besser: aufteilen
my @results = map { process($_) } @valid;

# 4. Deaktivieren von strict refs
no strict 'refs';                        # Fast immer falsch
${"My::Package::$var"} = $value;        # Stattdessen einen Hash verwenden

# 5. Globale Variablen als Konfiguration
our $TIMEOUT = 30;                       # Schlecht: veränderbares Global
use constant TIMEOUT => 30;              # Besser: Konstante
# Am besten: Moo-Attribut mit Standardwert

# 6. String-eval zum Laden von Modulen
eval "require $module";                  # Schlecht: Code-Injection-Risiko
eval "use $module";                      # Schlecht
use Module::Runtime 'require_module';    # Gut: Sicheres Laden von Modulen
require_module($module);

Erinnern Sie sich: Modernes Perl ist sauber, lesbar und sicher. Lassen Sie use v5.36 den Boilerplate-Code erledigen, verwenden Sie Moo für Objekte und bevorzugen Sie die kampferprobten Module von CPAN gegenüber selbst gestrickten Lösungen.