SELFHTML/Quickbar CGI/Perl Perl-Sprachelemente

| ## Variablen und Datentypen
| Skalare - einfache Variablen Listen - Arrays Hashs - assoziative Listen Referenzen - Zeiger auf Variablen

## Skalare - einfache Variablen

Variablen sind Speicherbereiche, in denen Sie Daten, die Sie im Laufe Ihrer Programmprozeduren benötigen, speichern können. Der Inhalt, der in einer Variablen gespeichert ist, wird als "Wert" bezeichnet. Sie können den Wert einer Variablen jederzeit ändern.

In Perl wird eine einfache Variable, die eine Zahl oder eine Zeichenkette speichern kann, als Skalar bezeichnet.

### Einzelbeispiele:

    $Name = "Methusalem";
    $Alter = 625;
    $Name_2 = "Junger Hansel";
    $JungAlter = sqrt($Alter);

### Beispiel eines kleinen Perl-Scripts:

    #!/usr/bin/perl
    $Wert = 123456;
    $Teilwert = substr($Wert,1,3);
    print $Teilwert;

### Erläuterung:

Ein Skalar, also eine einfache Variable, beginnt mit dem Dollarzeichen `$`, gefolgt von dem Namen der Variablen. Das Dollarzeichen muß immer angegeben werden, wenn die Variable verwendet wird, egal ob ihr ein Wert zugewiesen wird, oder ob sie in einer Operation vorkommt (so wie im letzten der obigen Einzelbeispiele die Variable `$Alter` innerhalb der Funktion `sqrt()` vorkommt, die die Quadratwurzel einer Zahl errechnet).

Sie können Skalare für numerische Inhalte und Skalare für Zeichenketten definieren. Ob ein Skalar numerisch oder eine Zeichenkette ist, entscheiden Sie, wenn Sie dem Skalar einen Wert zuweisen oder indem Sie ihn in einer Anweisung verwenden. Eine angegebene Zeichenkette muß dabei in Anführungszeichen stehen. Normalerweise sind das doppelte Anführungszeichen, es sind aber auch einfache Anführungszeichen erlaubt (zum Unterschied siehe Konventionen für Zeichenketten).

### Beachten Sie:

Daten in Perl sind nicht "getypt". Wenn Sie eine Zeichenkette haben, die nur aus gültigen numerischen Zeichen besteht (z.B. "7423.13"), können Sie damit problemlos numerische Operationen durchführen. Ebenso können Sie numerische Werte wie Zeichenketten behandeln. Zur Demonstration dazu dient das obige Beispiel eines kleinen Perl-Scripts. In dem Script wird ein numerischer Skalar `$Wert` definiert. Darunter wird jedoch eine typische Zeichenkettenfunktion auf diesen Skalar angewendet, nämlich das Extrahieren einer Teilzeichenkette mit Hilfe der Funktion `substr()`. Die Parameter der Funktion bedeuten: aus `$Wert` wird ab dem 2. Zeichen eine Zeichenkette von 3 Zeichen Länge extrahiert (das 2. Zeichen wird durch die Angabe von 1 bezeichnet, da in Perl, wie in den meisten anderen Programmiersprachen, immer bei 0 zu zählen begonnen wird). Das Ergebnis wird in einem Skalar `$Teilwert` gespeichert. Das Ergebnis lautet "234" und wird anschließend ausgegeben. Wenn Sie andere Programmiersprachen kennen, werden Sie hieran ermessen können, welche Freiheiten Sie in Perl beim Umgang mit Variablen haben.

## Listen - Arrays

Listen sind Ketten zusammengehöriger Skalare. In Perl haben solche Listen zentrale Bedeutung, weil es sehr einfach ist, Daten in Listen einzulesen und Listen zu manipulieren.

### Beispiel 1:

    #!/usr/bin/perl
    @Daten = ("Jana",23,"Berlin","Abitur");
    print $Daten[0], " ist ", $Daten[1], " Jahre alt, wohnt in ", $Daten[2], " und hat ", $Daten[3];

### Beispiel 2:

    #!/usr/bin/perl
    for($i = 1;$i <= 9;$i++)
     {
      $Wert = $i * $i;
      push(@Quadrate, $Wert);
     }
    for(@Quadrate)
     {
      print $_, "\n";
     }

### Beispiel 3:

    #!/usr/bin/perl
    @Buchstaben = ("a".."z");
    print $Buchstaben[2], "\n";

### Erläuterung:

Eine Liste wird in Perl durch das Klammeraffenzeichen `@` eingeleitet. Dahinter folgt der Name der Liste. Sie können eine Liste mit Daten vorbelegen, wie etwa in Beispiel 1 oben die Liste `@Daten`. Achten Sie dabei darauf, daß die Daten durch Klammern eingeschlossen werden. Die einzelnen Listenelemente trennen Sie durch Kommata.

Sie können die Liste aber auch dynamisch erzeugen, wie es oben in Beispiel 2 innerhalb einer Schleife geschieht. In dem Beispiel wird innerhalb einer Schleife, die von 1 bis 9 zählt, die Liste `@Quadrate` dynamisch mit den Quadratzahlen zu den Zahlen 1 bis 9 gefüllt. Das geht jedoch nur mit Unterstützung von Funktionen zur Listenmanipulation, im Beispiel durch die Funktion `push()`, die Elemente an das Ende einer Liste anfügt.

Das obige Beispiel 3 zeigt eine besondere Variante, um eine Liste mit Daten zu füllen. Um eine Liste mit Zahlen (von - bis) oder mit Buchstaben (von - bis) aufzufüllen, genügt es, beim Definieren der Liste das erste und das letzte Listenelement anzugeben und dazwischen einfach zwei Punkte zu notieren (im Beispiel werden auf diese Weise alle Kleinbuchstaben von a bis z in eine Liste mit entsprechend vielen Elementen geschrieben - `@Buchstaben = ("a".."z");`.

Wenn Sie eine Liste mit Daten vorbelegen oder füllen, gelten die gleichen Regeln wie bei einfachen Skalaren: Zeichenketten werden in Anführungszeichen notiert, Zahlen ohne Anführungszeichen. Anstelle von Daten können Sie natürlich auch Skalare in eine Liste einfügen. Dann wird der Wert des betreffenden Skalars in die Liste übernommen.

Um ein bestimmtes Element innerhalb einer Liste anzusprechen, verwenden Sie den Variablennamen der Liste, setzen jedoch ein Dollarzeichen `$` davor, genau so wie bei einem einfachen Skalar. Hinter dem Listennamen notieren Sie in eckigen Klammern, das wievielte Element der Liste Sie meinen. Dabei wird bei 0 zu zählen begonnen, d.h. das erste Listenelement einer Liste mit dem Namen `@Listenname` wird mit `$Listenname[0]` angesprochen, das zweite Element durch `$Listenname[1]` usw. Im ersten der obigen Beispiele können Sie das sehr gut studieren.

Die folgende Abbildung bezieht sich nochmals auf die obigen Beispiele 1 bis 3 und verdeutlicht, was jeweils in den Listen gespeichert ist, und wie die entsprechenden Listenelemente ansprechbar sind.

### Beachten Sie:

Es ist problemlos möglich, einen einfachen Skalar und ein Element einer Liste einander zuzuweisen. So können Sie beispielsweise eine Anweisung notieren wie:
`$Vorname = $Daten[0];`
Ebenso ist es problemlos möglich, eine ganze Liste zu kopieren und einer anderen Liste zuzuweisen, etwa so:
`@SpeicherDaten = @Daten;`.

Sie können Zeichenketten und Zahlen ohne Probleme in derselben Liste speichern, wie im Beispiel 1 oben. Es gibt auch keine Vorschriften dafür, wie lang ein einzelnes Listenelement maximal sein darf. So können Sie auch eine komplette andere Liste als Element in einer Liste speichern. Ein Element in einer Liste innerhalb einer Liste sprechen Sie dann beispielsweise mit `$Daten[2][4]` an (das heißt: das 3. Element der Liste `@Daten` ist selbst eine Liste, z.B. mit dem Namen `@Eigenschaften`, die selbst wieder mehrere Elemente enthält, und das 5. Element dieser Liste soll angesprochen werden).

Sie dürfen ohne vorherige Listendefinition eine Anweisung notieren wie:
`$Zahlen[5] = 43298;`
Dabei wird dann automatisch eine Liste namens `@Zahlen` erzeugt, die zum Zeitpunkt des Erzeugens 6 Elemente hat, nämlich `$Zahlen[0]` bis `$Zahlen[5]`. Dabei ist nur `$Zahlen[5]` mit einem Wert belegt, die anderen Listenelemente sind leer.

Das letzte Element einer Liste können Sie immer auch durch `$Listenname[-1]` ansprechen. Die negative Indexzahl -1 ist für diesen Zweck reserviert.

## Hashs - assoziative Listen

Gewöhnliche Listen bestehen aus einer Reihe von Werten, die über Indexnummern, beginnend bei 0, ansprechbar sind. So hat ist das 8. Element einer Liste mit dem Namen `@Listenname` über `$Listenname[7]` ansprechbar. Eine assoziative Liste, in Perl als Hash bezeichnet, speichert dagegen pro Listenelement zwei Werte: einen Namen und einen Wert. Werte innerhalb eines Hashs brauchen dann nicht über Indexnummern ansgesprochen zu werden, sondern werden über den zugehörigen Namen "assoziiert".

### Beispiel:

    #!/usr/bin/perl
    %Daten = ("Name","Jana","Alter",23,"Ort","Berlin");
    print $Daten{'Name'}, " ist ", $Daten{'Alter'}, " Jahre alt und wohnt in ", $Daten{'Ort'};

### Erläuterung:

Ein Hash wird in Perl durch das Prozentzeichen `%` eingeleitet. Wenn Sie einen Hash erzeugen und mit Daten vorbelegen, gehören immer jeweils zwei Elemente zusammen: das erste Element stellt den Hash-Namen dar, das zweite Element den gespeicherten Wert, der über den Hash-Namen ansprechbar ist. So bilden im obigen Beispiel die beiden ersten Elemente `"Name"` und `"Jana"` das erste Hash-Paar des Hashs `%Daten`.

Um ein bestimmtes Element innerhalb eines Hashs anzusprechen, verwenden Sie den Variablennamen des Hashs, setzen jedoch ein Dollarzeichen `$` davor, genau so wie bei einem einfachen Skalar. Hinter dem Namen des Hashs notieren Sie in geschweiften Klammern und einfachen Anführungszeichen den Hash-Namen des Elements, das Sie meinen. Im obigen Beispiel wird auf diese Weise etwa mit `$Daten {'Name'}` der zugehörige Wert `"Jana"` angesprochen.

### Beachten Sie:

Für Hashs, also für assoziative Listen, gelten ansonsten die gleichen Regeln und Möglichkeiten wie für gewöhnliche Listen.

Hashs lassen sich im Zusammenhang mit CGI-Scripts sehr sinnvoll einsetzen. So ist es beispielsweise möglich, den Datenstrom eines vom Anwender ausgefüllten HTML-Formulars in einen Hash einzulesen, wobei als Hash-Name jeweils der Name gespeichert wird, den ein Formularelement in der HTML-Datei hat, und als Wert der Wert, den der Anwender in dem betreffenden Formularelement eingegeben oder ausgewählt hat.

## Referenzen - Zeiger auf Variablen

Wenn Sie sich in der Sprache C auskennen, wissen Sie, was Zeiger sind, und wie effizient das Programmieren dadurch werden kann. Referenzen sind Zeiger auf zuvor definierte Datentypen (egal ob Skalare, Listen oder Hashs). Über Referenzen können Sie den Inhalt eines Skalars, einer Liste oder eines Hashs genau so ansprechen wie über den Originalnamen.

Das Besondere an Referenzen in Perl ist, daß der Wert einer Variablen so lange erhalten bleibt, wie es Referenzen dieser Variablen gibt. Das ist von Bedeutung, wenn Sie mit Unterprogrammen arbeiten, in denen lokal gültige Datentypen definiert werden.

### Beispiel:

    #!/usr/bin/perl

    &A();

    sub B()
    {
    print $$TextReferenz, "\n";   # Wert ist nur noch in der Referenz enthalten!
    }

    sub A()
    {
    my $Text = "Das ist ein kleiner Text";
    $TextReferenz = \$Text;   # Hier wird eine Referenz definiert
    &B();
    }

### Erläuterung:

Das obige Beispiel verdeutlicht die Wirkungsweise einer Referenz. Das kleine Perl-Script im Beispiel enthält zwei selbst definierte Unterprogramme `A()` und `B()`. Zuerst wird mit `&A()` das entsprechende Unterprogramm aufgerufen. Dort wird ein Skalar `$Text` definiert, dessen "Lebensdauer" sich auf die Unterroutine `A()` beschränkt. Erreicht wird das durch Voranstellen des Wörtchens `my`.
Im Anschluß an die Skalardefinition wird eine Referenz auf diesen Skalar definiert. Die Referenz wird genau so definiert wie der Skalar selbst. Bei der Zuweisung des Skalars zu der Referenz steht jedoch ein umgekehrter Schrägstrich `\`. Dadurch wird der Referenz `$TextReferenz` nicht der Wert von `$Text` zugewiesen, sondern lediglich die Speicheradresse, an der der Wert von `$Text` steht. Dadurch benötigt die Referenz selbst deutlich weniger Speicher als der Skalar.
Zuletzt wird innerhalb des Unterprogramms `A()` das Unterprogramm `B()` aufgerufen.
Im Unterprogramm `B()` wird der zugehörige Wert der Referenz $Referenztext mit der print-Funktion ausgegeben. Würde dort die Anweisung `print $Text;` stehen, würde nichts ausgegeben, da die Variable `$Text` aus `A()` mit ihrem Wert zu diesem Zeitpunkt nicht mehr existiert. Der Wert existiert aber trotzdem noch, da er noch über die Referenz `$TextReferenz` ansprechbar ist.
Um den Wert einer Referenz auf einen Skalar anzusprechen, müssen Sie zwei Dollarzeichen vor dem Namen der Referenz notieren, so wie in der print-Anweisung im obigen Beispiel.

### Beachten Sie:

Wenn Sie - zum Beispiel mit der print-Anweisung - nicht den Wert der Referenz ansprechen, sondern einfach die Referenz selbst, wird einfach in Hexadezimalform die Speicheradresse ausgegeben, an der der Inhalt der Referenz im Arbeitsspeicher steht.

Sie können nicht nur Referenzen auf Skalare, sondern auch Referenzen auf Listen und Hashs oder Referenzen auf einzelne Elemente innerhalb von Listen oder Hashs definieren. Die folgende Tabelle bietet dazu eine Übersicht, wie die entsprechende Notation aussehen muß.

Referenz auf... | Referenz definieren | Referenz-Wert ansprechen | Referenz-Wert ansprechen (alternative Notation)
--- | --- | --- | ---
Skalar | `$Skalarreferenz = \$Skalar` | `$$Skalarreferenz` | `${$Skalarreferenz}`
Liste | `$Listenreferenz = \@Liste` | `@$Listenreferenz` | `@{$Listenreferenz}`
Element in Liste | `$Listenreferenz = \@Liste` | `@{$Listenreferenz}[0]` | `$Listenreferenz->[0]`
Hash | `$Hashreferenz = \%Hash` | `%$Hashreferenz` | `%{$Hashreferenz}`
Element in Hash | `$Hashreferenz = \%Hash` | `%{$Hashreferenz}{"Hashname"}` | `$Hashreferenz->{"Hashname"}`

Beachten Sie, daß Referenzen erst ab der Perl-Version 5.0 interpretiert werden. Ältere Perl-Interpreter bringen Syntaxfehlermeldungen, wenn sie auf Referenzen stoßen.

Benutzen Sie Referenzen immer nur dann, wenn Sie einen Grund dazu haben!

weiter: | Vordefinierte Variablen in Perl
zurück: | Grundsätzliches zu Perl-Scripts

SELFHTML/Quickbar CGI/Perl Perl-Sprachelemente

© 1998 Stefan Münz, muenz@csi.com