Perl Tutorial

Dies ist eine Bearbeitung des Perl Tutorials von Nik Silver ( School of Computer Studies, University of Leeds GB). Das Ziel dieses Tutorials ist es, die Grundlagen von Perl zu erarbeiten, um effizient CGI-Scripts zu schreiben. Dabei geht es nicht darum, die Programmiersprache Perl erschöpfend zu behandeln, sondern um den Einstieg in weitere eigene Bemühungen zu schaffen. Diese HTML-Version ist als tar.gz - File verfügbar. 

Daneben gibt es für Perl V5 die Manpages in HTML-Format. oder ebenfalls tar.gz - File. 

Musterlösungen! Es kann schon mal vorkommen, dass dieser Link ins Leere zeigt. Dann gibt's nur eines: später probieren! 

Die folgende Themen werden in diesem Tutorial behandelt: 

1. Das erste Perl Programm 
• Die erste Zeile 
• Kommentare und Anweisungen 
• Einfache Ausgabe 
2. Ein Programm ausführen 
3. Skalare Variablen 
• Operationen und Zuweisungen 
• Interpolation 
• Uebung 
4. Array Variablen 
• Array Zuweisungen 
• Arrays ausgeben 
• Uebung 
5. Assoziative Arrays 
• Operatoren 
• Umgebungs-Variablen 
6. Files 
• Uebung 
7. Kontrollstrukturen 
• foreach 
• Bool'sche Operationen 
• for 
• while und until 
• Uebung 
8. Bedingungen 
• Uebung 
9. Mustererkennung 
• Reguläre Ausdrücke (RA) 
• Die Defaultvariable $_ 
• Mehr über RA's 
• Ein paar Beispiele 
• Uebung 
10. Ersetzen, Uebersetzen von Strings 
• Optionen 
• Muster wiederverwenden 
• Uebersetzen 
• Uebung 
11. Mehr String-Funktionen 
• Split 
• Substr 
• Uebung 
12. Binäre Daten und Files 
• Binäre Daten 
• Formattierte Ausgabe 
• Uebung 
13. Subroutinen 
• Parameter 
• Rückgabewerte 
• Lokale Variablen mit my 
• Lokale Variablen mit local 
• Uebung 
14. 'Typeglobs' und Referenzen 
• Typeglobs 
• Referenzen 
• Uebung 
15. Module 
• Packages 
• Klassen 
• Module 
• Uebung 1 
• Uebung 2 
16. Einführung in Perl 5 Objekte 

Das erste Programm

Hier ist das erste Programm um uns anzuwärmen. 

#!/usr/local/bin/perl
#
# Das unvermeidliche erste Programm
#
print 'Hello world.';           # Ausgabe eines Textes

Die erste Zeile

#!/usr/local/bin/perl

Kommentare und Anweisungen

Alles übrige sind Perl-Anweisungen, welche mit einem Strichpunkt beendet werden müssen, wie die letzte Zeile oben. 

Einfache Ausgabe

Sie werden feststellen, das obiges Programm ein nicht ganz erwartetes Resultat erzeugt. Wir werden es deshalb als nächstes laufen lassen. 
 

Ein Programm ausführen

Schreibe das Beispielprogramm mit einem Texteditor und speichere es ab. (Emacs hat einen Perl-Modus 'M-x perl-mode'!) 

Danach muss es ausführbar gemacht werden mit 

chmod u+x progname

perl progname
./progname
progname

perl -w progname

perl -d progname

Bevor wir weitermachen, sollte das Programm laufen. Der Output entspricht vielleicht nicht ganz den Erwartungen, mindestens ist er nicht so schön. Zunächst wenden wir uns den Variablen zu und danach können wir auch die Ausgaben verbessern. 
 

Skalare Variablen

Die elementarsten Variablen in Perl sind die skalaren Variablen. Skalare Variablen können Zahlen und Strings beinhalten und, je nach Kontext, werden sie als Zahlen oder Strings interpretiert. Vor dem eigentlichen Namen muss immer ein $ -Zeichen stehen. Im folgenden Beispiel 

$priority = 9;

$priority = 'high';

$priority = '9';
$default = '0009';

Variablennamen können aus Buchstaben, Zahlen und Unterstrich zusammengesetzt werden. Sie sollten jedoch nicht mit einer Zahl beginnen und die Variable $_ hat eine spezielle Bedeutung. Perl unterscheidet zwischen Gross- und Kleinschreibung, dh. $a und $A sind verschieden. 

Operationen und Zuweisungen

$a = 1 + 2;     # Addiere 1 und 2 und speichere Resultat in $a
$a = 3 - 4;     # Subtrahiere 4 von 3 ...
$a = 5 * 6;     # Multipiziere 5 und 6
$a = 7 / 8;     # Dividiere 7 mit 8 ($a = 0.875)
$a = 9 ** 10;   # Neun hoch zehn
$a = 5 % 2;     # % MOD 2
++$a;           # Inkrement $a, Rückgabe von $a
$a++;           # Rückgabe von $a, Inkrement $a
--$a;           # Dekrement $a, Rückgabe von $a
$a--;           # Rückgabevon $a, Dekrement $a

$a = $b . $c;   # Konkateniere $b und $c
$a = $b x $c;   # Füge $b $c-mal zusammen

$a = $b;        # $a wird $b
$a += $b;       # $a wird um $b vergrössert
$a -= $b;       # $a wird um $b verkleinert
$a .= $b;       # $a wird mit $b konkateniert

Weitere Operatoren sind im Manual beschrieben. Zugang zum Manual erhält man auch mit man perlop. 

Substitution

$a = 'apples';
$b = 'pears';
print $a.' and '.$b;

print '$a and $b';

print "$a and $b";

Uebung

Array Variablen

Eine weitere Art von Variablen sind die Array Variablen. Sie stellen eine Liste von skalaren Variablen dar (ie. Zahlen und Strings). Die Namen von Array-Variablen haben dasselbe Format, wie die skalaren Variablen, ausser das sie anstelle eines $-Symbols, am Anfang ein @-Symbol brauchen. Beispiel:

@food  = ('apples', 'pears', 'eels');
@music = ('whistle', 'flute');

Die Array-Elemente werden mittels Indizes in eckigen Klammern zugegriffen. Der Index beginnt bei 0. Der Wert von

$food[2]

Array Zuweisung

@moremusic = ('organ', @music, 'harp');
@moremusic = ('organ', 'whistle', 'flute', 'harp');

push(@food, 'eggs');

push(@food, 'eggs', 'lard');
push(@food, ('eggs', 'lard'));
push(@food, @morefood);

Analog kann mit pop das letzte Element von einer Liste entfernt werden. pop entfernt von der ursprünglichen Liste @food das letzte Element eels. Der Rückgabewert ist das entfernte Element. @food hat nun noch zwei Elemente: 

$grub = pop(@food);     # Jetzt ist $grub = 'eels' (grub=Frass)

$f = @food;

$f = "@food";

Arrays können auch verwendet werden, um gleichzeitig mehrere Zuordnungen von skalaren Variablen zu machen: 

($a, $b) = ($c, $d);            # Aequvalent $a=$c; $b=$d;
($a, $b) = @food;               # $a und $b sind die ersten
                                # beiden Elemente von @food.
($a, @somefood) = @food;        # $a ist das erste El. von @food
                                # @somefood sind die übrigen
(@somefood, $a) = @food;        # @somefood ist @food und
                                # $a ist nicht definiert.

Zum Schluss möchten wir noch die Länge eines Arrays bestimmen können. Der Ausdruck 

$#food

$len=$#food+1;

$len=$#food+1-$[;

Arrays ausgeben

print @food;    # 
print "@food";  # mit doppelten Anführungszeichen
print @food.""; # in skalarem Kontext (. Konkat.)

Uebung

Hashes (Assoziative Arrays)

Normale Arrays oder Listen erlauben den Zugriff zu den Elementen über die Elementnummern. Das erste Element des Arrays @food ist $food[0]. Das zweite Element ist $food[1], und so weiter. Mit Perl können aber auch Arrays erzeugt werden, deren Elemente durch Strings referenziert werden. Diese Arrays nennt man assoziative Arrays oder hashes (die keyword - value -Paare werden in Hash-Tabellen abgelegt.) 

Um einen Hash zu definieren verwenden wir die normale Klammer-Notation. Der Arrayname hat jedoch ein vorangestelles %-Zeichen (im Gegensatz zum @-Zeichen des gewöhnlichen Arrays). Wir wollen einen Hash definieren, welcher den Namen und das Alter von Personen enthält. Das sieht folgendermassen aus: 

%ages = ('Michael Caine', 39,
         'Dirty Den', 34,
         'Angie', 27,
         'Willy', '21 in dog years',
         'The Queen Mother', 108);

%ages = ('Michael Caine' => 39,
         'Dirty Den' => 34,
         Angie => 27,
         Willy => '21 in dog years',
         'The Queen Mother', 108);

$ages{'Michael Caine'};         # Ergibt 39
$ages{'Dirty Den'};             # Ergibt 34
$ages{Angie};                   # Ergibt 27
$ages{Willy};                   # Ergibt "21 in dog years"
$ages{'The Queen Mother'};      # Ergibt 108

$ages{'ich'} = 'jung';

Das %-Zeichen wird wiederum durch ein $-Zeichen ersetzt, falls ein einzelnes Element gemeint ist. Ein Element ist ein Skalar! Im Unterschied zu den normalen Arrays, wo der Index in eckigen Klammern geschrieben wird, verwenden wir bei den Hashes die geschweiften Klammern. Der Index ist ein String, eben der Name der Person. 

Ein Hash kann in einen normalen Array umgewandelt werden, indem er einfach einem normalen Array zugewiesen wird. Umgekehrt wird ein normaler Array in einen Hash umgewandelt. Idealerweise hat der normale Array eine gerade Anzahl Elemente: 

@info = %ages;          # @info ist ein normaler Array.
                        # Er hat jetzt 10 Elemente.
$info[5];               # Das 5. Element von @info
                        # den Wert 27
%moreages = @info;      # %moreages ist ein assoziativer
                        # Array. Es ist der gleiche wie %ages

Operatoren

foreach $person (keys %ages)
{
        print "Ich kenne das Alter von $person.\n";
}
foreach $age (values %ages)
{
        print "Jemand ist $age Jahre alt.\n";
}

Daneben gibt es noch eine Funktion each, welche einen Array mit zwei Elementen erzeugt, dem Schlüsselwort und dem Wert. Aufeinanderfolgende Aufrufe von each geben immer ein neues key/value-Paar aus, solange solche vorhanden sind: 

while (($person, $age) = each(%ages))
{
        print "$person ist $age Jahre alt\n";
}

Umgebungs-Variablen

print "Du bist User $ENV{'USER'} mit ";
print "Homedirectory $ENV{'HOME'}\n";

Files

Das folgende Perlprogramm liest ein File und gibt den Inhalt des Files aus. 

#!/usr/local/bin/perl
#
# Program to open the password file, read it in,
# print it, and close it again.

$file = '/etc/passwd';          # Filename zuweisen
open(INFO, $file);              # File öffnen
@lines = <INFO>;                # in Array einlesen
close(INFO);                    # File schliessen
print @lines;                   # Array ausgeben

Die Funktion close schliesst das File. 

Selbstverständlich möchten wir nicht nur Files lesen, sondern auch schreiben oder etwas zu einem File hinzufügen können. Die Verwendung des richtigen Prefix zum Filenamen der Funktion open erlaubt diese Dinge: 

open(INFO, $file);      # Lesen
open(INFO, ">$file");   # Schreiben
open(INFO, ">>$file");  # Anhängen
open(INFO, "<$file");   # Lesen

print INFO "This line goes to the file.\n";

Im obigen Programm wird ein File eingelesen. Der Filehandle ist INFO und um es einzulesen verwendet man spitze Klammern. Der Ausdruck 

@lines = <INFO>;

Die Filehandles STDIN, STDOUT und STDERR sind vordefiniert. Defaultmässig schreibt print auf STDOUT und <> liest von STDIN ( <> ist äquivalent zu <STDIN>). 

Uebung

Kontrollstrukturen

Weitere interessante Möglichkeiten werden mit Kontrollstrukturen und Schleifen eröffnet. Perl unterstützt viele verschiedene Arten von Kontrollstrukturen, welche zum Teil C ähnlich sehen, aber auch an Pascal erinnern. Wir werden hier ein paar davon ansehen. 

foreach

foreach $morsel (@food)         # Gehe der Reihe nach durch
                                # @food und nenne das 
                                # Element $morsel
{
        print "$morsel\n";      # Ausgabe des Elementes
        print "Yum yum\n";      # That was nice
}

Bool'sche Operatoren

$a == $b                # $a numerisch gleich $b?
                        # Achtung: Nicht = verwenden
$a != $b                # $a numerically ungleich $b?
$a eq $b                # $a gleicher String wie $b?
$a ne $b                # $a und $b nicht der gleiche String?

($a && $b)              # ist $a und $b true?
($a || $b)              # ist entweder $a oder $b true?
!($a)                   # ist $a false?

for

for (init; test; inkr)
{
         first_action;
         second_action;
         etc
}

for ($i = 0; $i < 10; ++$i)     # Starte mit $i = 1
                                # falls $i < 10
                                # Inkr. $i vor Block
{
        print "$i\n";
}

while und until

#!/usr/local/bin/perl
print "Password? ";             # Fragt nach Input
$a = <STDIN>;                   # liest input
chop $a;                        # löscht \n am Ende
while ($a ne "fred")            # Solange $a falsch ist
{
    print "sorry. Again? ";     # Fragt wieder
    $a = <STDIN>;               # liest
    chop $a;                    # löscht \n am Ende
}

Um das Gegenteil zu testen, können wir die until-Schleife in genau gleicher Weise verwenden. Damit wird der Block solange ausgeführt, bis der Test true ist und nicht solange er true ist. 

Eine andere Art vorzugehen, ist die Verwendung des while- oder until-Tests am Ende des Blocks anstatt am Anfang. Dazu benötigt man noch den do-Operator, welcher den Blockanfang markiert. Falls wir die Meldung sorry. Again weglassen, könnten wir das Passwortprogramm folgendermassen schreiben: 

#!/usr/local/bin/perl
do
{
        print "Password? ";             # Fragt nach Input
        $a = <STDIN>;           # liest Input
        chop $a;                # löscht \n
}
while ($a ne "fred");           # Nochmals solange falscher Input

Uebung

while ($line = <INFO>)
{
        ...
}

Bedingungen

Natürlich kennt Perl auch if/then/else-Anweisungen. Sie sehen wie folgt aus: 

if ($a) {
        print "The string is not empty\n";
} else {
        print "The string is empty\n";
}

Es gibt aber noch mehr Möglichkeiten: 

if (!$a) {                      # Das ! ist der NOT Operator
        print "The string is empty\n";
} elsif (length($a) == 1) {             # falls obiges false
        print "The string has one character\n";
} elsif (length($a) == 2) {             # falls obiges false
        print "The string has two characters\n";
} else {                                # andernfalls
        print "The string has lots of characters\n";
}

Uebung

Mustererkennung

Eine der nützlichsten Eigenschaften von Perl (wenn nicht die nützlichste Eigenschaft) ist das mächtige String-Handling. Und der Motor des String-Handling sind die regulären Ausdrücke (RA) zur Mustererkennung, welche auch von vielen UNIX Hilfsprogrammen verwendet werden. 

Reguläre Ausdrücke

$satz =~ /das/;

$satz =~ m:das:;

Der RA unterscheidet Gross- und Kleinschreibung, dh. mit 

$satz = "Das Muster kommt vor!";

$satz !~ /das/

Die Defaultvariable $_ 

if ($satz =~ /uster/) {
        print "Das Muster \'uster\' kommt vor.\n";
}

$satz = "Ein Muster ohne Wert";
$satz = "Uster mustern";

if (/uster/) {
        print "Wir sprechen von Mustern\n";
}

Mehr über RAs

Als Einstieg schauen wir uns ein paar einfache Beispiele an. Nehmen wir an, wir hätten einen String und möchten wissen, ob darin die Zeichenfolge ac vorkommt. Der RA dazu ist /ac/. Anstelle von ac möchten wir auch noch bc zulassen, dann heisst der RA /[ab]c/. Falls nun mehrere a's und b's vor dem c erlaubt sein sollen, können wir schreiben: /[ab]+c/. Folgende Menge von Strings sind damit erlaubt: 

ac
bc
aac
bc
abc
bac
aaac

Verlassen wir unser Beispiel und schauen uns weitere Spezialzeichen an: 

.       # Ein einzelner Buchstaben ohne newline
^       # Zeilen- oder Stringanfang
$       # Zeilen- oder Stringende
*       # Null oder mehrere Male den letzten Buchstaben, greedy!
*?      # ditto, aber minimal
+       # Ein oder mehrere Male den letzten Buchstaben
?       # Null oder ein Mal den letzten Buchstaben

t.e     # t gefolgt von einem bel. Buchstaben 
        # gefolgt von e
        # Dieses Muster ist enthalten in
        #                 the
        #                 tre
        #                 tle
        # aber nicht in te
        #          oder tale
^f      # f am Anfang einer Zeile
^ftp    # ftp am Anfang einer Zeile
e$      # e am Ende einer Zeile
tle$    # tle am Ende einer Zeile
und*    # un gefolgt von 0 oder mehreren d
        # Dieses Muster ist enthalten in
        #                 un
        #                 und
        #                 undd
        #                 unddd (etc)
.*      # Irgendein String ohne newline, weil
        # . bedeutet irgendein Buchstabe ausser newline
        # und * bedeutet 0 oder mehrere davon
^$      # Leerzeile

[qjk]           # Entweder q oder j oder k
[^qjk]          # Weder q noch j noch k
[a-z]           # Irgendetwas zwischen a und z (inklusive)
[^a-z]          # Keine Kleinbuchstaben
[a-zA-Z]        # Irgendein Buchstabe
[a-z]+          # Irgendeine Folge von Kleinbuchstaben

Ein senkrechter Strich | bedeutet ein "OR" und Klammern (...) werden verwendet, um Dinge zu gruppieren: 

jelly|cream     # Entweder jelly oder cream
(eg|le)gs       # Entweder eggs oder legs
(da)+           # Entweder da oder dada oder dadada oder...

\n              # Zeilenumbruch
\t              # Tabulator
\w              # Irgendein alphanumerischer (word) Buchstaben
                # ist identisch mit [a-zA-Z0-9_]
\W              # nicht alphanumerisch (non-word)
                # ist identisch mit [^a-zA-Z0-9_]
\d              # Eine Zahl. Ist identisch mit [0-9]
\D              # Keine Zahl. Ist identisch mit [^0-9]
\s              # 'whitespace character': space,
                # tab, newline, etc
\S              # 'non-whitespace character'
\b              # Wortgrenze  (nur ausserhalb [])
\B              # Innerhalb eines Wortes

\|              # Vertical bar
\[              # An open square bracket
\)              # A closing parenthesis
\*              # An asterisk
\^              # A caret symbol
\/              # A slash
\\              # A backslash

Ein paar Beispiele

[01]            # Enweder "0" or "1"
\/0             # Eine Division durch Null: "/0"
\/ 0            # Mit Leerzeichen: "/ 0"
\/\s0           # Mit 'whitespace':
                # "/ 0" wobei das Leerzeichen auch ein Tab
                # etc. sein kann0
\/ *0           # Kein oder mehrere Leerzeichen
                # "/0" or "/ 0" or "/  0" etc.
\/\s*0          # Kein oder mehrere 'whitespace'
\/\s*0\.0*      # Wie vorher, aber mit Dezimalpunkt
                # und möglicherweise weiteren Nullen, zB.
                # "/0." und "/0.0" und "/0.00" etc und
                # "/ 0." und "/  0.0" und "/   0.00" etc.

Uebungen

• dem Buchstaben q 
• dem String Du 
• dem String Du, welcher ein grosses oder ein kleines D haben kann 
• das Wort Du mit oder ohne Grossbuchstaben. Verwende \b um Wortgrenzen zu erkennen. 

Ersetzen, Uebersetzen in Strings

Sowie Perl Muster in Strings erkennen kann, können auch Muster durch Strings ersetzt werden. Dazu verwenden wird die s-Funktion, welche ähnlich wie im vi-Editor oder beim sed aussieht. Wiederum wird der Vergleichsoperator verwendet, welcher wiederum weggelassen werden kann, falls die Ersetzung auf der Defaultvariablen $_ gemacht werden soll. 

Um den Substring london durch London in der Variablen $satz zu ersetzen, verwenden wir die Anweisung 

$satz =~ s/london/London/;

s/london/London/;

Optionen

s/london/London/g;

Falls wir auch Dinge, wie lOndon, lonDON, LoNDoN, ersetzen wollen, könnte das ganze folgendermassen aussehen: 

s/[Ll][Oo][Nn][Dd][Oo][Nn]/London/g

s/london/London/gi;

Muster wiederverwenden

$_ = "Lord Whopper of Fibbing";
s/([A-Z])/:$1:/g;
print "$_\n";

Im folgenden Beispiel wird die Testanweisung 

if (/(\b.+\b) \1/)
{
        print "Found $1 repeated\n";
}

Der folgende Ausdruck vertauscht den ersten und den letzten Buchstaben einer Zeile in der $_-Variablen: 

s/^(.)(.*)(.)$/$3$2$1/

Nach einem Vergleich hat man drei Spezial-Variabeln $`, $& und $' zur Verfügung, in welchen die Teile vor, während und nach dem Muster abgespeichert sind. Nach 

$_ = "Lord Whopper of Fibbing";
/pp/;

$` eq "Lord Who";
$& eq "pp";
$' eq "er of Fibbing";

$search = "the";
s/$search/xxx/g;

$search = "the";
s/${search}re/xxx/;

Uebersetzen

$sentence =~ tr/abc/edf/;

$count = ($sentence =~ tr/*/*/);

tr/a-z/A-Z/;

Uebung

Zum Beispiel sollten folgende Zeilen erscheinen: 

«30?» Fabio Hi(pp)in steht auf dem Tre(pp)enabsatz und zieht kräftig an Sophies
«Du, sag mal: Hast Du schon a(ll)es gezügelt?»

countlines first second etc

Aendere das Programm, sodass es ein Argument akzeptiert und nur diejenigen Zeilen zählt, welche diesen String enthalten. Setze diese Vorkommnisse in Klammern. Damit wird 

countlines du

022Blackcurrant-Büchse (du)rch die Luft, die er mit einem Hechtsprung auf den

Mehr String-Funktionen

Split

Sie funktioniert folgendermassen: 

$info = "Benno:Müller:Kaufmann:Hauptstrasse 14";
@personal = split(/:/, $info);

@personal = ("Benno", "Müller", "Kaufmann", "Hauptstrasse 14");

@personal = split(/:/);

$_ = "Hugo:Huber::dipl. math.:::Dammweg 2";
@personal = split(/:+/);

@personal = ("Hugo", "Huber",
             "dipl. math.", "Dammweg 2");

$_ = "Hugo:Huber::dipl. math.:::Dammweg 2";
@personal = split(/:/);

den folgenden Array ergeben: 

@personal = ("Hugo", "Huber", "",
             "dipl. math.", "", "", "Dammweg 2");

@chars = split(//, $word);
@words = split(/ /, $sentence);
@sentences = split(/\./, $paragraph);

substr

substr("Once upon a time", 3, 4);       # returns "e up"
substr("Once upon a time", 7);          # returns "on a time"
substr("Once upon a time", -6, 5);      # returns "a tim"

Falls der negative Index vor den Anfang des Stringes zeigt, wird Perl nichts zurückgeben und eine Warnung ausgeben. Um das zu vermeiden, kann man einen String verlängern unter Verwendung des x-operators, den wir früher erwähnt haben. Zum Beispiel erzeugt der Ausdruck (" "x30) erzeugt 30 Leerzeichen. 

substr kann auch als lvalue verwendet werden (auf der linken Seite einer Anweisung):

$str = "It's a Perl World.";
substr($str, 7, 4) = "Small";    # It's a Small World
substr($str, 13, 0) = "Perl ";   # It's a Small Perl World

Uebung

discovered (this is the truth) that when he
t kinds of metal to the leg of a frog, an e
rrent developed and the frog's leg kicked,
 longer attached to the frog, which was dea
normous advances in the field of amphibian
ch it hop back into the pond -- almost.  Bu
ond -- almost.  But the greatest Electrical
ectrical Pioneer of them all was Thomas Edi

• Das ganze File soll in einen Array eingelesen werden (dies ist natürlich im Allgemeinen nicht angebracht, da das File sehr gross sein kann, aber wir wollen uns jetzt nicht darum kümmern.) Jede Zeile des Files ist ein Element des Arrays. 
• Die chop -Funktion mit einem Array als Parameter schneidet den letzten Buchstaben jedes Array-Elementes ab. 
• Wie wir schon gesehen haben, kann der gesamte Array mit folgender Anweisung zusammengefügt werden: $text = "@lines"; 
• Verwende die split-Funktion mit dem Suchstring als regulärer Ausdruck für die Trennstelle, an welcher der Text unterteilt werden soll. Das Resultat ist ein Array aller Substrings, welche vom Suchstring eingeschlossen sind. 
• Drucke der Reihe nach jedes Arrayelement, den Suchstring und das nächste Arrayelement aus 
• Beachte, dass das letzte Element des Arrays @food den Index $#food hat. 

Binäre Daten und Files

Als C-Programmierer kennt man die Funktionen, um in binären Files zu manövrieren. In Perl ist es sehr ähnlich: Für Lesen gibt es read, für Schreiben print (nein, nicht write!), für Positionieren seek und um die aktuelle Position im File zu erhalten tell. Diese Funktionen gelten auch für Textfiles, werden jedoch meistens in Files mit fester Recordlänge (fixed record length) verwenden, wo beliebiger Zugriff auf einzelne Records (random access) durch einfache Berechnungen möglich ist. 

Zuerst machen wir als einfaches Beispiel die Kopie eines Files mit read und print:

   open FROM, "InFile";
   open TO, ">OutFile";
   while (read FROM, $buf, 16384) {
       print TO $buf;
   }
   close FROM;
   close TO

( Es gäbe auch noch eine einfachere Möglichkeit, ein File zu kopieren: Mit dem Modul File::Copy. )

binäre Daten

• A,a ASCII String 
• b,B Bit String 
• h,H Hex String 

• c,C Signed/Unsigned Char 
• s,S Signed/Unsigned Short 
• i,I Signed/Unsigned Integer 
• l,L Signed/Unsigned Long 

• f Float 
• d Double 

• p Pointer to a null-terminated string. 

Ein Teil des C-Codes für obiges Beispiel sieht wie folgt aus:

   struct{char st[4]; int in; double d;} gaga;
   fwrite(&gaga, sizeof(gaga) 1 , fp)   (* FILE *fp *)

   $template = "a4 i d";
   $len = length pack($template,'',0,0)
   read(FP,$rec,$len)     # open FP, "filename";
   ($str,$in,$d) = unpack($template,$rec);

Formattierte Ausgabe

   format NAME =
   FORMLIST
   .

Beispiel: Wir möchten nun das binäre File, welches wir oben gelesen habe, schön formattiert ausgeben:

   format TOP =
             Binaeres File
   STRING       INTEGER        DOUBLE
   ----------------------------------
   .
   format =
   # String linksbuendig, Integer zentriert, Double rechtsbuendig
   @<<<<        @||||||        @>>>>>
   $str,$in,$d
   .
   
   while (read(FP,$rec,$len)) {
       ($str,$in,$d) = unpack($template,$rec);
       write;
   }

Uebung

Subroutinen

Wie jede gute Programmiersprache können in Perl eigene Funktionen programmiert werden. Man nennt sie in Perl Subroutinen (wie in Fortran!?). 

Sie können irgendwo im Programm platziert werden. Normalerweise wird man sie an den Anfang oder ans Ende des Programmes stellen. Wie in C kann eine Subroutine deklariert und später definiert werden unter Verwendung der Compilerdirektive use subs.

sub NAME;               # Deklaration
sub NAME(PROTO);        # Deklaration mit Prototypen
sub NAME BLOCK          # Definition
sub NAME(PROTO) BLOCK   # Definition mit Prototypen

sub mysubroutine
{
        print "Dies ist eine langweilige Subroutine.\n";
        print "Sie macht immer das gleiche!\n";
}

&mysubroutine;          # Aufruf ohne Parameter
&mysubroutine($_);      # Aufruf mit einem Parameter
&mysubroutine(1+2, $_); # Aufruf mit zwei Parametern

NAME(LIST);      # & ist fakultativ mit Klammern
NAME LIST;      # Klammern sind fakultativ falls vordefiniert oder importiert
&NAME;          # übergibt der Subroutine aktuellen @_ 

Parameter

sub printargs
{
        print "@_\n";
}

&printargs("perly", "king");    # Example prints "perly king"
&printargs("frog", "and", "toad"); # Prints "frog and toad"

sub printfirsttwo
{
        print "Der erste Parameter war $_[0]\n";
        print "und $_[1] war der zweite\n";
}

Rückgabewerte

sub maximum
{
        if ($_[0] > $_[1]) {
           $_[0];
        } else {
           $_[1];
        }
}

$biggest = &maximum(37, 24);    # $biggest ist 37

Lokale Variablen mit my

Häufig möchte man die Elemente von @_ einer eigenen lokalen Variablen zuordnen, etwa um die Lesbarkeit zu verbessern. Die folgende Subroutine testet, ob ein String Substring eines anderen ist, ohne die Leerzeichen zu berücksichtigen: 

sub inside
{
        my ($a, $b);                    # Erzeuge lokale Var.
        ($a, $b) = ($_[0], $_[1]);      # Param. zuordnen
        $a =~ s/ //g;                   # Leerzeichen aus lok.
        $b =~ s/ //g;                   #   Var. löschen
        ($a =~ /$b/ || $b =~ /$a/);     # Ist $b in $a
                                        #   oder $a in $b?
}

&inside("lemon", "dole money");         # true

my ($a, $b) = @_;

Lokale Variablen mit local 

my ist die neuere (abPerl 5) und effizientere Art lokale Variablen zu deklarieren. Der Unterschied zu local liegt in wichtigen Feinheiten. local erzeugt einen temporären Wert für eine globale Variable (dynamic scoping), wohingegen my eine echte lokale Variable deklariert (lexical scoping), welche nur im umgebenden Block, Subroutine (oder eval) bekannt ist. Die Syntax ist bei beiden gleich. 
Eine Einschränkung gibt es bei den Variablennamen: Mit my sind nur alphanumerische Zeichen erlaubt! Um Spezialvariablen, wie zB. $\ zu lokalisieren, muss local verwendet werden. 

Uebung

'Type Globs' und Referenzen

'Type Globs'

$foo = 100;
@foo = ('aa','bb','cc');
sub foo {
    print "I am foo\n";
}

sub deref {
    local(*bar) = @_;
    print $bar[0],"\n";
    print $bar,"\n";
    &bar;
}
print "Ref: ",*foo,"\n";
&deref(*foo);

Ref: *main'foo
aa
100
I am foo

Referenzen

Erzeugen von Referenzen

1. Mit dem Backslash-Operator: 

$scalarref = \$foo;
$arrayref  = \@ARGV;
$hashref   = \%ENV;
$coderef   = \&handler;
$globref   = \*STDOUT;

2. Als Referenz zu einem anonymen Array, Hash oder Funktion: 

$arrayref = [1, 2, ['a', 'b', 'c']];

$hashref = {'Adam' => 'Eve', 'Clyde' => 'Bonnie');

$coderef = sub { print "Boink!" };

3. Referenzen werden häufig durch spezielle Subroutinen, den Konstruktoren zurückgegeben: 

$objref = new Doggie (Tail => 'short', Ears => 'long');
$objref->bark();     # Aufruf einer Methode

4. Referenzen zu Filehandles werden durch Referenzen zu einem Typeglob erzeugt. Folgendes Beispiel zeigt, wie ein Filehandle als Parameter einer Subroutine übergeben wird: 

splutter(\*STDOUT);  #  Aufruf
sub splutter {       #  Deklaration
    my $fh = shift;
    print $fh "gugus\n";
}

Dereferenzieren

1. Ueberall, wo man einen Identifier als Teil eines Variablen- oder Subroutinennamens schreiben würde, kann dieser Identifier durch eine einfache skalare Variable, welche eine Referenz auf den gewünschten Typ darstellt, ersetzt werden. 

$bar = $$scalarref;
push(@$arrayref, $filename);
$$arrayref[0] = "Januar";
$$hashref{"KEY"} = "VALUE";
&$coderef(1,2,3);
print $globref "output\n";

2. Ueberall, wo man einen Identifier als Teil eines Variablen- oder Subroutinennamens schreiben würde, kann dieser Identifier durch einen BLOCK, welcher eine Referenz auf den gewünschten Typ zurückgibt, ersetzt werden. 

$bar = ${$scalarref};
push(@{$arrayref}, $filename);
${$arrayref}[0] = "Januar";
${$hashref}{"KEY"} = "VALUE";
&{$coderef}(1,2,3);

In diesen Fällen ist es natürlich überflüssig die geschweiften Klammern zu verwenden. Aber da ein Block einen beliebigen Ausdruck beinhalten kann, gibt es vernünftigere Beispiele: 

&{ $dispatch{$index} }(1,2,3);   # Aufruf der korrekten Subroutine

3. Als syntaktische Variante geht auch: 

$arrayref->[0] = "Januar";
$hashref->{"KEY"} = "VALUE";

Die linke Seite vom Pfeil kann irgendein Ausdruck sein, welcher eine Referenz zurückgibt. 

$array[$x]->{"foo"}->[0] = "Januar";

Vor dieser Anweisung könnte $array[$x] undefiniert sein, wird aber an dieser Stelle automatisch zu einer Referenz auf einen Hash. Dasselbe gilt analog für $array[$x]->{"foo"}. Die Pfeile zwischen den Klammern müssen nicht geschrieben werden: 

$array[$x]{"foo"}[0] = "Januar";

4. Eine Referenz kann aber auch eine Referenz auf ein Objekt (zu einer Klasse) sein. Dann gibt es vermutlich Methoden, welche durch diese Referenz zugegriffen werden können: 

$obj->methode($param);

Wir werden im nächsten Kapitel mehr davon hören. Und dann gibt es noch die perlobj-Manpage. 

Mit den Referenzen von Perl 5 ist es einfach mehrdimensionale Datenstrukturen (Arrays von Arrays, Arrays von Hashes, Hashes von Subroutinen etc. zu erzeugen (siehe perldsc- resp. perlLoL-Manpage). 
Weitere Angaben über Referenzen findet man in den perlref -Manpage.

Referenzen als Parameter von Subroutinen

@letzte = popmany( \@a, \@b, \@c, \@d );
sub popmany {
    my $aref;
    my @retlist = ();
    foreach $aref (@_) {
        push @retlist, pop @$aref;
    }
    return @retlist;
}

($aref, $bref) = func(\@a, \@b);
print "@$aref has more then @$bref\n";
sub func {
    my ($cref, $dref) = @_;
    if (@$cref > @$dref) {
        return ($cref, $dref);
    } else {
        return ($dref, $cref);
    }
}

Uebung

Module

Packages

$Package::Variable
$Package'Variable   (Notation von Perl V4)

{ 
package MyPack; 
$foo = 100; 
$bar = 'aaa'; 
$::spe = 'hallo'; # oder $main::spe 
} 
$foo = 200; $bar = 'bbb'; 
print $foo, $bar; # 200bbb 
print $MyPack::foo, $MyPack::bar; # 100aaa 
print $spe; # hallo 

Die package-Anweisung wird häufig an den Anfang eines Files gesetzt, welches mit der require-Anweisung von einem anderen File verwendet wird. 

Konstruktoren und Destruktoren von Packages

Perl-Klassen

package subclass;
@ISA = (baseclass);
sub new {
    my $self = {};
    bless $self;
    return $self;
}

Module

Will man zum Beispiel ein Modul mit dem Namen Gugus definieren, erzeugt man ein File mit dem Namen Gugus.pm und setzt folgende Zeilen an den Anfang dieses Files: 

package Gugus;
require Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(func1 func2);
@EXPORT_OK = qw($hugo @egon %mueller func3);

Perl Module werden mit use aufgerufen: 

   use Module;

   use Module LIST;

   BEGIN {require "Module.pm"; import Module; }

   BEGIN (require "Module.pm"; import Module LIST; }

Alle Perl-Module sollten die Endung '.pm' haben. use nimmt an, dass diese Endung vorhanden ist und ergänzt den Filenamen entsprechend. Schauen wir uns noch ein letztes Beispiel an, welches den Unterschied zwischen use und require aufzeigt: 

require "Cwd.pm";       # Cwd:: 
$here = Cwd::getcwd();

use Cwd;           # Importiere Symbole von Cwd
$here = getcwd();

use Cwd();         # Importiere leere Liste von Cwd
$here = getcwd();  # Fehler: getcwd() nicht bekannt!!

require "Cwd.pm";       # Cwd:: 
$here = getcwd();  # Fehler: kein main::getcwd()!!

% perl -V     # gibt viele Einzelheiten über die Installation an
              # inklusive @INC , den Modul-Suchpfad
% perldoc perldoc  # Modulbeschreibungen

Uebung 1

Startverzeichnis
# wechseln
Tmp-Verzeichnis
Fileliste
# zurück wechseln
Startverzeichnis

• readdir 
• `ls` resp qx{ ls } 
• Pipe von /bin/ls: 

open(FILES,"/bin/ls *|");
while ($File = <FILES>) {..}

Uebung 2

use Module;
use Module LIST;

Einführung in Perl 5 Objekte 

Viele Leute schrecken vor den praktischen Perl5-Modulen zurück, weil diese mit Objekten zu tun haben. Und das ist ja schon mal verdächtig und tönt nach etwelchen Schwierigkeiten ohne entsprechend nützlich zu sein. 

Auf der anderen Seite führen gewisse Probleme automatisch hin zu Objekten. Das macht den Leuten Angst. Unnötigerweise. 

Es ist ein riesiger Unterschied genügend über OO-Programmierung zu wissen, um Module zu verwenden , oder um Module selber entwerfen und implementieren zu können. Man befürchtet das letztere können zu müssen um Zugang zum ersteren zu erhalten. Das ist weit weg von der Realität. 

Man muss nicht viel wissen um Module verwenden zu können. Man lädt einfach die Library und ruft die dokumentierten "Konstruktoren" auf. "Konstruktoren" sind die Dinge, welche neue Objekte erzeugen. Häufig werden sie new genannt. 

In Perl5 werden ein oder zwei neue Konzepte verwendet, welche Sie vielleicht bisher noch nie gesehen haben: 

• Die Anweisung use Module lädt ein Modul mit dem Namen Module.pm (zur Kompilationszeit) und fügt die exportierten Namen in Ihren Namensraum ein. Die Anweisung require Module lädt das Modul ebenfalls, aber erst zur Laufzeit und importiert keine Namen. 
• Der Pfeil-Operator für die Dereferenzierung -> bedeutet ein Aufruf einer Methode (Subroutine) eines Objektes. In OO-Slang sagt man auch 'dem Objekt eine Message senden'. Dabei braucht man keinerlei Kenntnisse über den Aufbau des Objektes. Es ist einfach eine Black Box, welche Subroutinen zur Verfügung stellt. Das ist alles. 
• Die folgenden zwei Zeilen sind aequivalent. Die zweite Zeile ist jedoch syntaktisch ein wenig klarer: 

    $obj = new CGI;
    $obj = CGI->new();

• Wie jeder andere Unterprogrammaufruf, kann eine Methode irgend etwas zurückgeben, sogar ein anderes Objekt. 

   use LWP::UserAgent;
   $ua = new LWP::UserAgent;
   $ua->agent("Mozilla/5.0PlatinumB3");  # hee :-)

   $req = new HTTP::Request GET => 'http://perl.com/perl/';
   $req->header('Accept' => 'text/html');

   # send request
   $result = $ua->request($req);

   # check the outcome
   if ($result->is_success) {
      print $result->content;
   } else {
      print "Error: " . $result->code 
                . " " . $result->message;
   }

Hier sind noch ein paar Beispiele für den Gebrauch von perl WWW-Modulen: 

   use CGI;
   $req = CGI->new();

   use CGI::Imagemap;
   $map = CGI::Imagemap->new();

   use HTML::Parse;
   $html = parse_htmlfile("test.html");

   use URI::URL;
   $url = URI::URL->new('gisle.gif','http://www.com/%7Euser');

   use HTTP::Request;
   $hreq = HTTP::Request->new('GET', 'http://www.perl.com/');