Perl 2

Perl 3

Perl 4

Perl 5

Perl 6

Zurück

Reguläre Ausdrücke

Einführung in Perl III

von Achim Schmidt

Im zweiten Teil unserer Perl-Serie haben wir uns einfache Stringoperationen und Kontrollstrikturen angesehen. Dieser Teil befaßt sich nun mit regulären Ausdrücken.

Was ist ein regulärer Ausruck

Ein regulärer Ausdruck ist ein Zeichenmuster, welches mit einer Zeichenkette verglichen wird. Das Ergebnis dieses Vergleiches kann entweder eine Übereinstimmung oder keine sein. Die Leistungsfähigkeit regulärer Ausdrücke geht jedoch über einen einfachen Vergleich bei weitem hinaus. So können auch ganze Teile von Zeichenketten, in Abhängigkeit der Übereinstimmung, ersetzt werden.
Reguläre Audrücke an sich sind auch nichts Perl-spezifisches, sondern sie sind einer Vielzahl von Standard-Unix-Werkzeugen (wie beispielsweise grep, vi,...) bekannt. Zugegeben ist die Syntax und der Vorrat an diesen Ausdrücken in den verschiedenen Anwendungen sehr unterschiedlich, aber Perl verfügt über einen recht großen Vorrat an regulären Ausdrücken.

Der Übereinstimmungsoperator

Der Übereinstimmungsoperator in Perl ist die Zeichenkombination =~ . Sie erwartet auf der linken Seite eine Skalarvariable und auf ihrer rechten Seite einen regulären Ausdruck. Links steht also die Zeichenkette, auf welche der reguläre Ausdruck angewendet wird.

Aufbau von regulären Audrücken

Perl sieht eine Zeichenkette dann als regulärer Ausdruck an, wenn sie von Schrägstrichen umgeben wird (wie dieses Zeichen zu ändern ist, sehen wir an späterer Stelle). Demnach wäre /test/ ein einfacher regulärer Ausdruck. Schauen wir uns dies doch einmal im kompletten Kontext einer Anweisung an:

$eingabe =~ /test/

Diese Eingabe überprüft also, ob der in Schrägstriche eingeschlossene Ausdruck in der Skalarvariablen $eingabe enthalten ist und liefert bei einer Übereinstimmung ein 'true' zurück und bei keiner festgestellen Übereinstimmung ein 'false'. Diese Rückgabe kann nun auch mit bereits bekannten Kontrollmechanismen abgeprüft werden. Aber verdeutlichen wir uns dies doch einfach an einem Beispiel (Siehe Abbildung 1).

Abbildung 1: demo3-1.pl

#!/usr/bin/perl print "\nZeichenkette: "; chop ($eingabe = <STDIN>); print "\nSuchtext: "; chop ($such = <STDIN>); if ($eingabe =~ /$such/) { print "Die Kombination '$such' wurde in '$eingabe' gefunden\n\n"; } else { print "'$such' ist in '$eingabe' nicht enthalten !\n\n"; }

as@thor:/home/as/txt/lnxmag/perl/3 > demo3-1.pl Zeichenkette: Dies ist ein erster Test Suchtext: erster Die Kombination 'erster' wurde in 'Dies ist ein erster Test' gefunden as@thor:/home/as/txt/lnxmag/perl/3 > demo3-1.pl Zeichenkette: Dies ist ein zweiter Test Suchtext: erster 'erster' ist in 'Dies ist ein zweiter Test' nicht enthalten ! as@thor:/home/as/txt/lnxmag/perl/3 >

Wie arbeitet dieses Programm nun? Der Benutzer wird aufgefordert, eine Zeichenkette einzugeben, welche mit einer zweiten einzugebenen Zeichenkette untersucht werden soll. An Hand der Formulierung der Eingabeaufforderung sieht man nun auch eine weitere der Stärken von Perl. In Perl sind Verschachtelungen an fast allen denkbaren Stellen möglich, was zwar nicht immer zur besseren Lesbarkeit des Quelltextes beiträgt, aber dem Autor beim Programmieren sehr leicht von der Hand geht und jede Menge Tipperei erspart. Die Anweisung

chop ($eingabe = <STDIN>);

liest Zeichen von der Standardeingabe ein und legt diese in der Skalarvariablen $eingabe ab, welche gleichzeitig von Ihrem letzen Zeichen ( in diesem Fall das Newline) befreit wird, so daß nach der Abarbeitung dieser Zeile in $eingabe bereits der weiterverarbeitbare Text ohne das störende Newline enthalten ist.

In der folgenden Programmzeile ist nun ein if - Konstrukt zu sehen, welches einen regulären Ausdruck enthält, welcher auf die Variable $eingabe (die ja links des Übereinstimmungoperator steht) angewendet wird. Der reguläre Ausdruck ist in diesem Fall /$such/ . Wie man deutlich sieht, steht innerhalb der Schrägstriche gleich die Variable in welchen wir vorher das Vergleichmuster gespeichert haben. Damit ist eigentlich auch schon klar, daß innerhalb regulärer Ausdrücke eine Variablenersetzung stattfindet, da dieses kleine Programm ansonsten doch recht sinnnlos wäre.

Der reguläre Ausruck überprüft nun, ob in $eingabe die in $such gespeicherten Zeichen enthalten sind, und liefert true (bei Übereinstimmung) oder false zurück. Diese Rückgabe wird nun von der, den regulären Ausdruck umgebenden, if-Anweisung ausgewertet. Ist dieser Rückgabewert wahr, die Überprüfung also erfolgreich, so wird der erste Anweisungsblock (hinter der if-Bedingung) ansgeführt. Liefert der reguläre Ausdruck dagegen ein false (wenn keine Übereinstimmung festgestellt werden konnte) wird der Anweisungsblock hinter der else-Anweisung ausgefürt.

Dieses Programm überprüft also, ob ein frei wählbarer Ausdruck innerhalb einer beliebigen Zeichenkette enthalten ist (und dabei ist es egal an welcher Stelle !).

Eine weitere, bereits erwähnte Funktionalität regulärer Ausdrücke ist das Ersetzen von Teilzeichenketten. Auch dies ist eine recht triviale Angelegenheit. Der reguläre Ausdruck wird dabei um eine Substitutionsanweisung und einer Ersatzzeichenkette erweitert. Die Substituionsanweisung steht dabei vor dem ersten Schrägstrich und wird duch ein kleines s sysmbolisiert. Die Ersatzzeichenkette wird an das abschließende Slash angehangen und ebenfalls mit einem weitere Schrägstrich abgeschlossen. Ein entsprechende regulärer Ausdruck sieht also folgendermaßen aus:

s/test/testausdruck/

Bei der Anwendung dieses regulären Ausdruckes mit dem Übereinstimmungsoperator und einer entsprechenden Variable würde in dieser das Wort test gegen das Wort testausdruck ersetzt werden. Zu beachten dabei ist, daß es direkt innerhalb der Variablen ersetzt wird und nicht etwa einer Kopie, d.h. wird der Originalinhalt der entsprechenden Variable noch benötigt, so muß er vorher in eine andere Variable, welche nicht mit dem regulären Ausdruck bearbeitet wird kopiert werden (einfache Zuweisung $b = $a; ).

Sehen wir uns doch nochmal ein kleines Beispielprogramm an, in welchem die Substitutionsfunktionalität eines regulären Ausdruckes benutzt wird:

Abbildung 2: demo3-2.pl

#!/usr/bin/perl print "\nZeichenkette: "; chop ($eingabe = <STDIN>); print "\nSuchtext: "; chop ($such = <STDIN>); print "\n neuer Text: "; chop ($ersetz = <STDIN>); print "\nIhre Eingabe: $eingabe"; $eingabe =~ s/$such/$ersetz/ ; print "\nNach Ersetzung: $eingabe\n\n" ;

as@thor:/home/as/txt/lnxmag/perl/3 > demo3-2.pl Zeichenkette: Dies ist ein kleiner Versuch Suchtext: Versuch neuer Text: Test Ihre Eingabe: Dies ist ein kleiner Versuch Nach Ersetzung: Dies ist ein kleiner Test as@thor:/home/as/txt/lnxmag/perl/3 >

Dieses kleine Programm liest nun drei Zeichenketten ein. Eine, in welcher gesucht und verändert werden soll ($eingabe), die zu suchende (zu ändernde) Zeichenkette ($such) und die Zeichenkombination, welche eingesetzt werden soll ($ersetz).

Anschließend wird der eingegebene Text in $eingabe nocheinmal ausgegeben und der reguläre Ausdruck mit Substituionskommando auf sie angwandt. Nach dessen Abarbeitung wird die Variable $eingabe erneut ausgegeben, welche nun jedoch nicht mehr den Originaltext sondern den veränderten Text enthällt.

Einzelzeichen und Zeichenmuster

Wie wir in Zeichenketten nach anderen Zeichenketten suchen können, haben wir uns ja bereits angesehen. Reguläre Ausdrücke sind jedoch noch weitaus flexibler. So kann auch nach bestimmten Zeichenmustern gesucht werden, wie beispielsweise nach Zahlen oder Buchstabenmustern. Der reguläre Ausdruck /[0-9]/ liefert true, wenn die zu überprüfende Zeichenkette eine oder mehrere Ziffern zwischen 0 und 9, also eine belibige Ziffer enthält. Allgemein kann man aufeinander folgende Zeichenmuster in dieser Form angeben. Dabei ist das erste Zeichen hinter der eckigen Klammer das Startzeichen, gefolgt von einem Minuszeichen und dem Endzeichen. Den Abschluß dieser Gruppe bildet dann die geschloßene, eckige Klammer. Demzufolge würde der reguläre Ausdruck /[a-f]/ auf alle kleingeschrieben Buchstaben zwischen a und f passen, was er auch tatsächlich tut. Was aber nun, wenn man auf einige Einzelzeichen prüfen möchte, welche nicht hintereinander liegen ? Auch dies ist relativ einfach. Es werden einfach alle Einzelzeichen, deren Vorkommen ein true liefern soll innerhalb der eckigen Klammer angegeben. Der reguläre Ausruck /[aeiou]/ passt demnach auf alle kleingschriebenen Vokale.

In folgendem Beispiel wird überprüft ob eine Eingabe Ziffern enthällt und ein unterschiedlicher Text nach diesem Kriterium ausgegeben.

Abbildung 3: demo3-3.pl

#!/usr/bin/perl print "\nZeichenkette: "; chop ($eingabe = <STDIN>); if ($eingabe =~ /[0-9]/) { print "Die Eingabezeile enthällt Ziffern !\n\n"; } else { print "Die Eingabezeile enthällt keine Ziffern !\n\n"; }

Nachdem die Eingabezeile eingelesen und in der Variable $eingabe (ohne Newline) gespeichert wurde wird mittels des regulären Ausdruckes /[0-9]/ überprüft, ob in der Variable $eingabe Ziffern enthalten sind. In Abhängigkeit des Rückgabewertes wird nun der entsprechende Anweisungsblock ausgeführt.

Negative Ausdrücke

Auch Negationen sind innerhalb regulärer Ausdrücke möglich. Das Caret (^) Zeichen (Hut) ist dabei der Verneinungsoperator. Am besten sehen wir uns dazu auch erst einmal ein Beispiel an:

Abbildung 4: demo3-4.pl

#!/usr/bin/perl print "\nZeichenkette: "; chop ($eingabe = <STDIN>); if ($eingabe =~ /[^0-9]/) { print "Ihre Eingabe ist keine ganze Zahl !\n\n"; } else { print "Die Eingabe ist eine ganze Zahl !\n\n"; }

Dieses Programm prüft, ob die eingegebene Zeichenkette eine ganze Zahl ist, also nur die Zeichen von Null bis 9 enthällt. Der reguläre Ausdruck liefert hier ein true sobald andere Zeichen als Ziffernzeichen eingegeben werden und false, falls nur Ziffern in der Eingabe auftreten. Es wird hier also wirklich mit einer negativen Logik gearbeitet, welche innerhalb des regulären Ausdruckes durch das Hütchenzeichen symbolisiert wird.

Die wichtigsten Zeichengruppen liefert Perl auch schon als Kürzel mit, welche in nachfolgender Tabelle aufgelistet sind:

Kürzel	gleichbedeutend		Bedeutung

\d	[0-9]			Ziffern 

\w	[a-zA-Z0-9_]		komplette Woerter (alle Buchstaben, Ziffern und Unterstrich)

\s	[ \r\t\n\f]		Leerraum (Space,Tab,Carrige Return, Linefeed, Formfeed)

Nimmt man anstelle der Kleinbuchstaben die entsprechenden Großbuchstaben, so hat dies die gleiche Wirkung wie ein der gleichbedeutenden Gruppe vorangestelltes Caret Zeichen.

Zeichenmustergruppen

Richig flexibel werden reguläre Ausdrücke, wenn man nach Zeichenmustergruppen suchen kann, etwa in der Art wie, liefere true, bei sieben dieser Zeichen.

Die einfachste Zeichenmustergruppe haben wir schon kennengelernt. Dies ist beispielsweise die bereits besprochene Suche nach aufeinanderfolgende Zeichen wie im Beispiel demo.3-1.pl.

Nun ist es jedoch auch möglich bestimmte Zeichen zu vervielfachen. Der reguläre Ausdruck /bo*t/ würde also bei einer Zeichekette true liefern, welche ein b, gefolgt von keinem, einem oder mehreren o's, gefolgt von einem t, enthält. Das bedeutet, daß sowohl bt, bot und boot ein true als Rückgabewert erzeugen würden, nicht aber bob.

Das Sternchen steht in regulären Ausdrücken demnach für null oder mehrere des voranstehenden Zeichen. Ein Gruppierungszeichen mit ähnlicher Bedeutung ist das +, welches für ein oder mehrere folgende Vorkommen des voranstehenden Zeichens steht. Ein ebenfalls in diese Sparte gehörendes Gruppierungszeichen ist das Fragezeichen. Es steht für Null oder eines des vorstehenden Zeichens.

Alle bisher erläuterten Zeichen funktionieren natürlich auch im Zusammenhang mit der Substitutionsfunktion bei regulären Ausdrücken. Sehen wir uns dazu folgendes Beispiel in Abbildung 5 an.

Abbildung 5: demo3-5.pl

#!/usr/bin/perl print "\nZeichenkette: "; chop ($eingabe = <STDIN>); print "Ihre Eingabe: $eingabe\n\n"; $eingabe =~ s/Sauerstofff?lasche/Luftvorrat/ ; print "Nach der Änderung: $eingabe\n\n";

Dieses Beispiel wandelt sowohl die Eingabe Sauerstoffflasche als auch Sauerstofflasche in das Wort Luftvorrat um, jedoch kein anderes Wort, d.h. es wandelt das Wort Sauerstofflasche in Luftvorrat, unabhängig davon, ob es mit zwei oder drei f geschrieben wurde.

Verankerungen

Neben den bereits erwähnten regulären Ausdrücken, kennt Perl noch Optionen um Zeichenmuster zu verankern. Eine normale Überprüfung einer Zeichenkette mittels regulärer Ausdrücke bedeutet, daß der reguläre Ausdruck mit jedem Teil des Strings verglichen wird. Mittels Verankerungen ist es jedoch möglich dies auch bestimmte Eigenschaften, wie etwa Wortanfang oder Wortgrenzen, zu beschränken.

Der erste Anker, wäre der Anker \b. Dieser bestimmt, daß ein Teil der Übereinstimmung auf eine Wortgrenze fallen muß, d.h. der reguläre Ausdruck /Test\b/ würde beim Auffinden der Zeichenkette Test wahrliefern, nicht jedoch bei Testdruck. Wird also der Anker \b hinter einen Ausdruck gesetzt, so muß er am Ende eines Wortes innerhalb der zu überprüfenden Zeichenkette stehen.

Der reguläre Ausdruck /test\b/ würde beispielsweise:

teststring nicht finden, da test nicht am Wortende steht
test finden, da es am Wortende (=gesamtes Wort) steht
Stringtest finden, da es am Ende der Zeichenkette Stringtest steht

Steht der Anker hingegen vor dem entsprechenden Ausruck (z.B. /\btest/), so muss es am Anfang eines Wortes innerhalb der zu prüfenden Zeichenkette stehen.

Dementspechend trifft der Ausdruck /\btest\b/ nur auf Zeicheketten zu, welche das Wort test als eigenes Wort (also ohne Zusammensetzungen) enthalten, da auf eine Wortgrenze am Anfang und Ende geprüft wird.

Der Anker \B legt fest, daß an der enstprechenden Stelle im zu testenden String explizit keine Wortgrenze sein darf. Dies bedeutet also, daß der reguläre Ausdruck /Test\B/ true liefert, wenn der zu überprüfende Ausdruck Testdruck ist, jedoch false bei Test oder DruckerTest.

Alternativen

Darüberhinaus ist es auch möglich auf verschiedene Muster hin zu prüfen. Dazu muß man die entsprechenden Alternativen innerhalb des regulären Ausdruckes mit dem Pipezeichen Verknüpfen. /Test|Demo/ liefert demnach wahr, sobald in der zu testenden Zeichenkette entweder das Wort Test oder Demo (an beliebiger Stelle) enthalten ist. Dazu wieder ein kleines Beispiel:

Abbildung 6: demo3-6.pl

#!/usr/bin/perl print "\nZeichenkette: "; chop ($eingabe = <STDIN>); if ($eingabe =~ /Test|Demo/) { print "In '$eingabe' ist Test oder Demo vorhanden\n\n"; } else { print "In '$eingabe' ist weder Test noch Demo vorhanden !\n\n"; }

Dieses Programm gibt eine Erfolgsmeldung aus, sobald Ihre Eingabe die Worte Test, Demo oder beide enthält.

Zwischenspeichern von Mustern

Eine weitere, höchst flexible Operation regulärer Ausdrücke ist das Zwischenspeichern beliebiger Teile eines Zeichenmusters. Am Ergebnis des regulären Ausdruckes wird nichts geändert, jedoch eine Zwischenspeicherung des Ausdruckes, welcher zur erfolgreichen Überprüfung führte, veranlaßt. Auf diesen Wert kann anschließen dann zurückgegriffen werden.

Schauen wir uns das doch am besten an einem Beispiel an:

Abbildung 7: demo3-7.pl

#!/usr/bin/perl print "\nZeichenkette: "; chop ($eingabe = <STDIN>); if ($eingabe =~ /(Test|Demo).*\1/) { print "$1 ist in '$eingabe' doppelt vorhanden ! \n\n"; } else { print "Weder Test noch Demo sind doppelt in '$eingabe' vorhanden \n\n"; }

as@thor:/home/as/txt/lnxmag/perl/3 > demo3-7.pl Zeichenkette: Dies ist ein Test für den Test Test ist in 'Dies ist ein Test für den Test' doppelt vorhanden ! as@thor:/home/as/txt/lnxmag/perl/3 > demo3-7.pl Zeichenkette: Dies ist eine Demo für den Test Weder Test noch Demo sind doppelt in 'Dies ist eine Demo für den Test' vorhanden as@thor:/home/as/txt/lnxmag/perl/3 >

Was macht dieses kleine Programm nun? Zuest nimmt es eine beliebige Eingabe vom Standardeingabegerät entgegen und kürzt diese um ein \n. In der anschließenden if-&Abfrage ist nun der reguläre Ausdruck

$eingabe =~ /(Test|Demo).*\1/

zu finden. Dieser bewirkt nun folgende Überprüfung: Zuerst wird nach Test oder Demo gesucht, welche hier jedoch in Klammern stehen. Diese Klammern sind die Kennzeichnung für die Zwischenspeicherung. Gespeichert wird der erste Wert, welcher auf das Suchmuster zutrifft, hier also das erste Vorkommen von Test oder Demo. Das .* innerhalb des regulären Ausdruckes steht für beliebig viele Zeichen. Der Punkt steht dabei für ein beliebiges Zeichen, welcher durch den Multiplikationsoperator * beliebig oft (auch Null mal) vorkommen darf. Anschließend steht im regulären Ausdruck ein \1 . Dieses \1 ist nun ein Zugriff auf den vorher (ersten) zwischengespeicherten Wert. Der Reguläre Ausdruck prüft also auf Test oder Demo, beliebig viele Zeichendazwischen und ein wiederholtes Vorkommen des ersten gefundenen Wertes aus dem geklammerten Ausduck. Kurz gesagt, er prüft auf das doppelte Vorkommen von Test oder Demo innerhalb der angegebenen Zeichenkette (hier in $eingabe). In der Ausgabe ist nun noch zu beachten, das der doppelt vorhandene Audruck ausgegeben wird, naemlich mittels der Variablen $1, welche von Perl mit dem ersten zwischengespeicherten Wert belegt wird !

Das if Konstrukt wertet die Rückgabe des regulären Ausdruckes aus und gibt eine entsprechende Meldung aus. Dieses kleine Programm ist, so denke ich zumindest, wirklich ein schönes Beispiel für die Leitungsfähigkeit regulärer Ausdrücke, wenn man einmal den Programmieraufwand für eine entsprechnde Funktion ohne Anwendung regulärer Ausdrücke bedenkt.

Sollen mehrer Zeichenmuster zwischengespeichert werden, so ist auch dies möglich, indem einfach mehrere Klammerungen verwendet werden, auf welche dann mit \1, \2, \3, usw. zugegriffen werden kann. Die entsprechenden Werte stehen nach der Abarbeitung automatisch in den entsprechenden Skalarvariablen !

Caseinsensitive Bearbeitung

Bislang haben wir nur mit Casesensitiver Vorgehensweise gearbeitet, sprich Groß- und Kleinschreibung wurde beachtet. Selbst verständlich kann man auch dies ändern, indem das dem regulären Ausdruck einfach mitgeteilt wird. Das geht über den Operator i, welcher ans Ende des regulären Ausdruckes gestellt wird, also hinter das abschließende Slash. Der reguläre Ausdruck /test/i würde also z.B. bei einem Vorkommen von Test, TeSt, test, ... ein true liefern.

Variablenersetzung

Noch ein Wort zur Variablenersetzung. Wir bereits erwähnt, findet innerhalb des regulären Audruckes eine Variablenersetzung statt, und zwar eine sehr genaue, was zur Folge hat, daß Suchmuster innerhalb der Variablen nicht als Text, sondern wirklich als Suchmuster behandelt werden. Dies bedeutet also, daß wir im Beispielprogramm demo3-1.pl in $such auch komplette Suchmuster angeben können, welche auch angewendet werden. Trotz aller Schönheit und Nützlichkeit dieser Funktion, kann sie auch sehr störend sein (Siehe dazu das Beispiel in Abbildung 7).

Abbildung 7: Beispiel mit demo3-1.pl

as@thor:/home/as/txt/lnxmag/perl/3 > demo3-1.pl Zeichenkette: Dies ist die Eingabezeile Suchtext: [fz]eile Die Kombination '[fz]eile' wurde in 'Dies ist die Eingabezeile' gefunden as@thor:/home/as/txt/lnxmag/perl/3 >

In diesem Beispiel wird also nicht nach dem Text [fz]eile gesucht, der in der Eingabe ja gar nicht vorhanden war, sondern nach zeile oder feile, da der eingegebene Suchtext als Muster behandelt wird. Diese Funktion kann man jedoch unterdrücken, indem man die zu ersetzende Variable mit den Operatoren \Q und \E umgibt.

Unser abgeändertes Programm ist in Abbilidung 8 zu sehen..

Abbildung 8: demo3-8.pl

#!/usr/bin/perl print "\nZeichenkette: "; chop ($eingabe = <STDIN>); print "\nSuchtext: "; chop ($such = <STDIN>); if ($eingabe =~ /\Q$such\E/) { print "Die Kombination '$such' wurde in '$eingabe' gefunden\n\n"; } else { print "'$such' ist in '$eingabe' nicht enthalten !\n\n"; }

as@thor:/home/as/txt/lnxmag/perl/3 > demo3-8.pl Zeichenkette: Dies ist die Eingabezeile Suchtext: [fz]eile '[fz]eile' ist in 'Dies ist die Eingabezeile' nicht enthalten ! as@thor:/home/as/txt/lnxmag/perl/3 >

Der gleiche Progammaufruf würde nun negativ ausgehen, da wirklich nach dem eingegebenen Suchtext gesucht wird und dieser nicht mehr als Muster betrachtet wird (Siehe Abbildung 8).

Vordefninierte Variablen

Einige Variablen, welche nach dem Arbeiten mit Suchmustern von Perl vorbelegt werden, kennen wir ja bereits schon. Erinnern Sie sich? Es waren $1 bis $n, welche den zwischengespeicherten Textteil enthalten. Perl setzt jedoch noch weitere Variablem. Dies sind $`, welche den Text vor der zu true führenden Zeichenfolge enthält, $& , welche den zum true führenden Text enthält und schließlich noch $' welche den Text nach $& enthält.

Ich denke, daß Sie nun von der Leitungsfähigkeit regulärer Ausdrücke überzeugt sein dürften, obwohl ich bei weitem nicht auf all deren Möglichketen eingegangen bin, da dies den Rahmen dieses Artikels um einiges sprengen dürfte. Ich hoffe jedoch eine recht gute Auswahl getroffen zu haben, da diese Anwendungen in Ihrer täglichen Perlerei wohl häufiger zum Einsatz kommen dürften.

Literatur

Larry Wall & Randal L. Schwartz: Programming Perl, 2nd Edition O'Reilly & Associates, Inc. ISBN 1-56592-6 Randal L. Schwartz: Einführung in PERL O'Reilly International Thomson Verlag ISBN 3-930673-08-8
Perl Quick Reference: http://www.pcnet.com/~rhswain/perl.html Perl FAQ: http://www.perl.com/perl/faq/index.html Perl CGI Programming FAQ: http://www.perl.com/perl/everything_to_know/index.html Perl OOP Tutorial: http://www.perl.com/perl/all_about/perltoot.html

Der Autor

Achim Schmidt ist staatlich geprüfter Assistent für Automatisierungs- und Computertechnik (HBFS) und beschäftigt sich bereits seit 6 Jahren intensiv mit dem Internet und seinen Diensten. Mit Linux wurde er erstmalig 1992 beim Aufbau eines Mailboxsystemes direkt konfrontiert. Seit 1993 sind bereits einige Publikationen (http://www.saar.de/~as/publications/) von ihm in verschiedenen Medien erschienen . Seit 1995 ist er als Netzwerk- und Systemmanager tätig und beschäftigt sich dabei auch mir der Entwicklung und Realisierung WWW- basierter Onlinesysteme und Internetkopplungen. Zu erreichen ist er unter as@Saar.DE.

teststring	nicht finden, da test nicht am Wortende steht
test	finden, da es am Wortende (=gesamtes Wort) steht
Stringtest	finden, da es am Ende der Zeichenkette Stringtest steht