Einführung in die Programmiersprache Perl

Inhalt:

• Vorbemerkung
• Datentypen
  • Skalare
    • Konstanten
      • Zahlen
      • Zeichenketten
    • Variable
    • Ausdrücke , Operatoren
  • Vektoren (Listen)
  • Assoziative Vektoren
  • Filehandles
• Funktionen
• Anweisungen
  • Ausdrücke als Anweisungen
  • Kontrollstrukturen
• Deklarationen
  • Unterprogramme
  • Formate

Vorbemerkung

Diese Einführung ist für wirkliche Anfänger gedacht. Sie soll einen ersten Einblick in die Struktur und Darstellungsweise von Perl-Programmen geben und strebt an keiner Stelle Vollständigkeit an. Daher sind für Operatoren, Funktionen u. andere Sprachelemente nur ganz wenige Beispiele angegeben. Wer konkrete Anwendungen in Perl schreiben möchte, sollte unbedingt das Buch "Lerning Perl" von Randal L. Schwartz lesen und anschließend auf das Buch "Programmieren in Perl" von Larry Wall und Randal L. Schwartz zurückgreifen.

Insbesondere wird auf die Behandlung der regulären Ausdrücke ganz verzichtet, weil sie für das Verständnis der Struktur der Sprache nicht erforderlich sind.

Datentypen

Skalare

Konstante

Zahlen

Zahlen werden in üblicher Weise eingegeben und von Perl intern grundsätzlich als doppelt genaue Gleitpunktzahlen dargestellt.

Eine führende 0 leitet eine Oktalzahl, 0x eine Hexadezimalzahl ein.

Beispiele:

3.14159           # nichts besonderes
-6.5e-23          # Exponentialschreibweise
377               # Integer-Literal, intern als Gleitpunktzahl gespeichert
0377              # Oktalzahl, ist dezimal 255
0xAA              # Hexadezimalzahl, ist dezimal 170

Zeichenketten

Eine Zeichenkette besteht aus einer beliebigen Anzahl von 8-Bit-Zeichen. Die kürzeste Zeichenkette enthält überhaupt kein Zeichen. Zeichenketten werden in Apostrophe oder Doppelapostrophe (Gänsefüßchen) eingefasst. Zwischen beiden Darstellungen gibt es einen großen Unterschied.

Zeichenketten in einfachen Apostrophen werden zeichengetreu (ohne irgendwelche Ersetzungen) übernommen; mit zwei Ausnahmen ( \' steht für einen Apostroph innerhalb der Zeichenkette und \\ für einen backslash).

In Zeichenketten, die in Doppelapostrophe eingeschlossen sind, werden Variable (s.u.) durch ihren Wert ersetzt. Außerdem gibt es eine ganze Reihe von Ersatzdarstellungen für nicht druckbare Zeichen.

Beispiele:

'what\'s happening?'          # Die Zeichenkette lautet: what's happening?
$neu = 123;                   # $neu ist eine skalare Variable (s.u.)
'*** $neu ***'                # Die Zeichenkette lautet: *** $neu ***    
"*** $neu ***"                # Die Zeichenkette lautet: *** 123 ***
"erste Zeile\nzweite Zeile"   # Die Zeichenkette lautet: erste Zeile
                                                         zweite Zeile

Variable

Die Namen von skalaren Variablen werden durch ein Dollarzeichen und einen Buchstaben eingeleitet; danach können Buchstaben Ziffern oder _ folgen. Eine skalare Variable kann einen numerischen Wert oder eine Zeichenkette enthalten. Vor der ersten Wertzuweisung hat sie den Wert undef.

Ausdrücke, Operatoren

Konstanten und Variable werden mit Operatoren zu Ausdrücken verbunden. Jeder Ausdruck hat einen Wert und kann auch als Anweisung geschrieben werden (eine Anweisung wird von der nächsten durch ein Semikolon getrennt). Es gibt also in Perl keine so strikte Trennung zwischen Ausdrücken und Anweisungen wie in anderen Sprachen. Der wichtigste Ausdruck (bzw. die wichtigste Anweisung) ist die Wertzuweisung:

$neu = 123;                  # Der Variablen $neu wird der Wert 123
                             # zugewiesen. Als Ausdruck betrachtet hat
                             # das Gebilde auch den zugewiesenen Wert (hier 123)

Damit ist auch

$a = 3+ ($b = 4)             # $b hat den Wert 4 und $a den Wert 7

zulässig.

Bei Bedarf werden Zeichenketten automatisch in numerische Werte und umgekehrt umgewandelt. Daher ist die folgenden Wertzuweisung durchaus in Ordnung:

$a = 'Die Zahl '.3.142.' ist ungefähr gleich pi.' 

Der Operator '.' verkettet zwei Zeichenketten.

Es gibt eine große Anzahl von vordefinierten skalaren Variablen mit fester Bedeutung. Einige Beispiele:

$_                       # enthält die aktuelle Eingabezeile bzw. wird für
                         # den aktuellen Mustervergleich benutzt.
$@                       # enthält z.B. die Fehlermeldung der letzten
                         # eval- Anweisung (s.u.)
$<                       # Benutzerkennung dieses Prozesses

Es gibt in Perl keinen expliziten Typ boolean oder dergleichen. Für Wahrheitswerte gilt: Dort wo aufgrund der Syntax ein Wahrheitswert benötigt wird, wird eine leere Zeichenkette oder die Zeichenkette '0' als falsch und alle anderen als wahr interpretiert. Ein numerischer Wert wird zuvor in eine Zeichenkette umgewandelt. Das ist sehr praktisch (aber nichts für Puristen).

Ein Ausdruck hat also je nach Bedarf einen numerischen, nichtnumerischen bzw. logischen Wert. Dieses Prinzip ist noch umfassender. Ein Ausdruck hat auch in der Regel je nach Bedarf einen skalaren und einen vektoriellen Wert.

Vektoren (Listen)

Ein Vektor (oder eine Liste oder ein Array, ganz nach Geschmack) ist eine geordnete, endliche Folge von Skalaren. Dabei können sogar numerische und nichtnumerische (Zeichenketten) Skalare in demselben Vektor vorkommen. Die einzelnen Skalare werden, durch Kommata getrennt, in runde Klammern geschrieben. Variablennamen werden wie die für slalare Variablen gebildet, aber mit @ statt mit $. Beispiele:

(1,4,9,16)               # Vektor mit 4 numerischen Elementen
()                       # leerer Vektor
(5..9)                   # andere Schreibweise für (5,6,7,8,9)
('eins',2,'drei')        # durchaus korrekt
@a = (1,$b,$_);          # vektorielle Wertzuweisung
@single = 1;             # einelementiger Vektor, dasselbe wie:
@single = (1);           #
($a,$b,$c) = (4..6)      # vektorielle Schreibweise für drei skalare
                         # Wertzuweisungen. In diesem Fall dürfen links
                         # natürlich nur Variable und keine Ausdrücke stehen

Auf die Elemente eines Vektors (auch auf Teilbereiche) kann auch mit Index-Ausdrücken (in eckigen Klammern) zugegriffen werden. Die Indizes beginnen grundsätzlich bei 0:

@v = (1,2,3);
$a = $v[2];              # Einzel-Elemente werden mit $ geschrieben!
                         # $a hat den Wert 3.
@b = @v[0,1];            # Namen vonTeilbereichen werden mit @ eingeleitet
$v;                      # ist eine von @v völlig unabhängige skalare Variable
$c = @v;                 # $c erhält den Wert 3 (s.u.)

In skalarem Zusammenhang (z.B. bei der Zuweisung an einen Skalar) hat ein vektorieller Ausdruck als Wert die Anzahl der Elemente.

Entsprechend den vordefinierten skalaren Variablen gibt es auch vordefinierte Vektoren:

@ARGV                    # enthält die Befehlszeilen-Argumente

Assoziative Vektoren

Assoziative Vektoren sind Listen von Paaren (Index, Wert), wobei für diese Paare keine festgelegte Reihenfolge existiert. Mit dem (nichtnumerischen) Index kann sofort auf den zugehörigen Wert zugegriffen werden. Namen für assoziative Vektoren werden mit % eingeleitet. Beispiele für die Verwendung von assoziativen Vektoren:

%mon = ('jan','Januar','feb','Februar');    # Zuweisung von Index-Wert- Paaren
$mon{'mar'} = 'März';                       # Zugriff auf einzelne Elemente
delete $mon{'mar'};                         # Löschen einzelner Elemente

Filehandles

Der Zugriff auf Dateien erfolgt mit sog. Filehandles. Ein Filehandle ist ein Name (hier wird zur optischen Unterscheidung von anderen Namen Großschreibung empfohlen) in spitzen Klammern. An Stellen, wo aufgrund der Syntax nur ein Filehandle stehen kann (z.B. in der open- und close-Anweisung) werden die spitzen Klammern weggelassen.

open (EIN,'buch.txt');       # das Filehandle <EIN> wird der Datei buch.txt
                             # zugewiesen.
$a = <EIN> ;                 # Jeder (skalare) Zugriff auf <EIN> liefert die
                             # nächste Zeile einschließlich '\n' am Ende.
@a = <EIN> ;                 # @a enthält als Elemente die Zeilen von buch.txt
close (EIN);                # schließt die Datei buch.txt.
open (AUS, '>ergebnis');     # öffnet die Datei ergebnis für Ausgabe
open (LOG, '>>logfile');     # öffnet die Datei logfile zum Anfügen

Die Filehandles <STDIN>, <STDOUT> und <STDERR> stehen immer zur Verfügung.

Funktionen

In Perl stehen viele vordefinierte Funktionen zur Verfügung. Einige wurden schon weiter oben benutzt. Es gibt keine Unterscheidung in "functions" und "subroutines". Jede Funktion liefert einen Wert (skalar bzw. vektoriell) und kann daher in Ausdrücken verwendet werden. Viele Funktionen lösen außerdem eine bestimmte Aktion aus, so dass ihr Aufruf als alleinstehende Anweisung sinnvoll ist. Die Namen vordefinierter Funktionen sind reserviert und dürfen nicht beispielsweise als Filehandle verwendet werden. Daher wird, um auch Konflikten mit zukünftig reservierten Namen vorzubeugen, empfohlen, die Namen von Filehandles groß zu schreiben.

Die Argumente von Funktionen werden als Liste in Klammern angegeben. Manche Funktionen lassen auch den Aufruf ohne Klammern zu. Beispiele:

print (STDOUT,"Guten Tag!\n");         # 
print ("Guten Tag!\n");                # das besondere Filehandle STDOUT kann
                                       # weggelassen werden
print "Guten Tag!\n";                  # ebenso die Klammern
$a = print "Guten Tag!\n";             # $a hat den Wert 1, wenn print 
                                       # erfolgreich war, sonst 0

Die Funktion chop() entfernt das letzte Zeichen aus der Zeichenkette, die als Parameter angegeben wird und liefert dieses Zeichen als Wert. chop wird häufig eingesetzt, um '\n' aus Eingabezeilen zu entfernen.

$a = 'hallo';
$b= chop ($A);                         # $a enthält 'hall', $b enthält 'o'

Anweisungen

Ausdrücke als Anweisungen

In Perl kann jeder Ausdruck, insbesondere ein Funktionsaufruf, als Anweisung mit abschließendem Semikolon geschrieben werden.

Kontrollstrukturen

Mehrere Anweisungen können, mit geschweiften Klammern eingefasst, zu Blöcken zusammengefasst werden. Solche Blöcke werden in Kontrollstrukturen verwendet. Einige Beipiele:

if (irgendein_ausdruck){          
    erste_anweisung;            # diese Anweisungen werden ausgeführt, wenn
    zweite_anweisung;           # der Ausdruck wahr ist
} else {
    erste_sonst_anweisung;      # und diese, wenn der ausdruck falsch ist
    zweite_sonst_anweisung;     #
}
while (irgendein_ausdruck){          
    erste_anweisung;            # diese Anweisungen werden ausgeführt solange
    zweite_anweisung;           # der Ausdruck wahr ist
} 

Deklarationen

Variable werden in Perl nicht explizit deklariert. Sie werden bei ihrer ersten Verwendung angelegt (notfalls mit dem Wert undef). Nur eigene Unterprogramme und Formate (s.u.) müssen deklariert werden. Die Deklarationen können irgenwo im Programm stehen (zweckmäßigerweise am Ende).

zurück zum Inhaltsverzeichnis

Unterprogramme

Die Deklaration eines Unterprogramms hat die Form

sub unterprogrammname {
    anweisungen;
}

Der Aufruf dieses Unterprogramms hat die Form

&unterprogrammname (liste_der_parameter);

Im Unterprogramm stehen die Parameter in dem speziellen Vektor @_ zur Verfügung. Dieser Vektor ist im Unterprogramm lokal deklariert. Auf die einzelnen Parameter kann den Regeln entsprechend mit $_[0], $_[1] u.s.w. zugegriffen werden (das hat nichts mit der besonderen Variablen $_ zu tun). Die Variablen des Hauptprogramms stehen im Unterprogramm als globale Variable zur Verfügung. Um ein Unterprogramm sicherer zu schreiben, können (und sollten) bei Bedarf lokale Variable deklariert werden:

local ($lokaler_skalar, @lokaler_vektor,...);

Der Funktionswert eines Unterprogramms ist der des zuletzt ausgewerteten Ausdrucks.

Formate

Formate dienen dazu, auf einfache Weise strukturierte Berichte auszugeben. Hier wird der ursprüngliche Zweck von Perl als einer "Practical Extraction and Report Language" deutlich. In dieser Einführung soll lediglich die Verwendung von Formaten anhand eines vollständigen Programmbeispiels gezeigt werden.

#!/usr/local/bin/perl
#
# Die Datei kongress enthalte die Anschriften von Kongressteilnehmern
# in der Form:
# name;strasse;plzort
# jeweils eine Adresse pro Zeile. Diese sollen spaltengerecht mit
# Seitenüberschriften ausgegeben werden.
open (LISTE,'teilnehmerliste');
open (EIN,'kongress');
while (<EIN>) {
   # bei jedem Schleifendurchgang liefert <EIN> eine neue Zeile.
   # Erst am Ende der Datei wird eine leere Zeichenkette geliefert
   # und damit die Schleife beendet. Die gelesene Zeile steht in $_
   # mit abschließendem '\n' zur Verfügung.
   chop; # ohne Parameter wirkt chop auf $_ und entfernt damit '\n'.
   ($name,$strasse,$plzort) = split(/;/);
   # split (/trenn/,ausdr) liefert einen Vektor der Teilzeichenketten
   #                       von ausdr, die durch den Separator trenn
   #                       voneinander getrennt sind. Fehlt ausdr, so
   #                       wirkt split auf $_
   write LISTE;
   # write schreibt in die angegebene Datei unter Verwendung des
   # gleichnamigen Formats
}
format LISTE =            # Deklaration des Ausgabeformats
@<<<<<<<<<<<<<<<<<<<<
$name
      @<<<<<<<<<<<<<<<<<<<<
      $strasse
      @<<<<<<<<<<<<<<<<<<<<
      $plzort
.      # Der Punkt beendet die Formatdeklaration
format LISTE_TOP =        # Deklaration der Kopfzeilen

Teilnehmerliste
19. Bundeskongress der 
Gesellschaft zur Rettung vom Genitiv
-----------------------------------------------
.      # Dieser Punkt beendet die Deklaration der Kopfzeilen 

---

Zuletzt geändert: 02.05.1995 (webadm)

FürHinweise und Vorschläge wenden Sie sich bitte per E-Mail an webmaster@hrz.uni-giessen.de