# Listen bzw. Arrays (Variablen)

| Listen bzw. Arrays deklarieren und Werte zuweisen Auf einzelne Listenelemente zugreifen Mehrdimensionale Arrays Funktionen und Operationen zum Manipulieren von Listen

## Listen bzw. Arrays definieren

Listen sind miteinander verkettete Einzelwerte. Wenn Sie so etwas Zusammengehöriges wie "alle Namen von HTML-Elementen" oder "alle Zeilen einer Datei" speichern wollen, können Sie dies mit Hilfe von Listen tun. Der Variablentyp in Perl, in dem Listen gespeichert werden können, heißt Array.

### Beispiel eines vollständigen CGI-Scripts:

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

    use strict;
    use CGI::Carp qw(fatalsToBrowser);

    my @Daten = ("Jana",23,"Berlin","Abitur");

    print "Content-type: text/html\n\n";
    print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
    print "<html><head><title>Testausgabe</title>\n";
    print "</head><body>\n";

    print "<pre>@Daten</pre>";

    print "</body></html>\n";

### Erläuterung:

Im Beispiel wird ein Array namens `@Daten` deklariert. "Deklaration" bedeutet bei Arrays das gleiche wie bei Skalaren. Ein Array wird in Perl durch das Klammeraffenzeichen `@` eingeleitet. Dahinter folgt der Name des Arrays. Bei der Deklaration eines Arrays können Sie Anfangswerte zuweisen oder auch nicht. Im obigen Beispiel werden Anfangswerte zugewiesen. Die Einzelwerte werden dabei wie gezeigt in runde Klammern eingeschlossen und untereinander durch Kommata getrennt. Wenn Sie keine Anfangswerte zuweisen wollen, notieren Sie einfach so etwas wie `my @Daten;` als Anweisung. Im Gegensatz zur Deklaration von Skalaren ohne Wertzuweisung ist die Liste dann nicht "undefiniert", sondern einfach leer.

Ein Array in Perl kann nur Skalare als Einzelwerte enthalten. Im obigen Beispiel sind die Einzelwerte `Jana`, `Berlin` und `Abitur` Zeichenketten, während `23` eine Zahl ist.

Das Beispiel sendet HTML-Code an den aufrufenden Browser und gibt dabei einfach die Liste aus.

### Beachten Sie:

Skalare, Listen und Hashes haben unterschiedliche Namensräume. Variablen wie `$name`, `@name` und `%name` können also problemlos im gleichen Script vorkommen.

Anstelle von konstanten Daten können Sie auch andere Variablen in eine Liste einfügen. Dann wird der Wert der betreffenden Variablen in die Liste übernommen. Zum Beispiel:
`my $Alter = 23;`
`my @Daten = ("Jana",$Alter,"Berlin","Abitur");`

Wenn Sie eine Liste mit auf- oder absteigenden Zahlen oder Buchstaben erzeugen wollen, gibt es dafür eine spezielle Syntax:
`my @Liste = (1..10);` erzeugt eine Liste mit 10 Elementen, nämlich den Zahlen 1 bis 10.
`my @Liste = ("A".."Z");` erzeugt eine Liste mit 26 Elementen, nämlich den Buchstaben von A bis Z.

Wenn Sie eine Liste mit Elementen erzeugen wollen, die keine Leerzeichen enthalten, gibt es dafür ebenfalls eine spezielle Syntax:
`my @Daten = qw(Jana 23 Berlin Abitur);` erzeugt einen Array mit den Elementen `Jana`, `23`, `Berlin` und `Abitur`. Bei dieser speziellen Syntax können Sie jedoch keine Variablen in die Liste einfügen.

## Auf einzelne Listenelemente zugreifen

Der Variablentyp für einen einzelnen Wert ist in Perl ein Skalar. Wenn Sie in einem Array auf einen einzelnen darin gespeicherten Wert zugreifen wollen, benutzen Sie also einen "skalaren Kontext". Dies kommt in der Syntax von Perl auch zum Ausdruck.

### Beispiel eines vollständigen CGI-Scripts:

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

    use strict;
    use CGI::Carp qw(fatalsToBrowser);

    my @Daten = ("Jana",23,"Berlin","Abitur");

    print "Content-type: text/html\n\n";
    print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
    print "<html><head><title>Testausgabe</title>\n";
    print "</head><body>\n";

    print "$Daten[0] ist $Daten[1] Jahre alt, wohnt in $Daten[2] und hat $Daten[3]\n";

    print "</body></html>\n";

### Erläuterung:

Im Script wird wieder ein Array `@Daten` deklariert und mit vier Werten initialisiert. Das Script erzeugt HTML-Code und gibt die Daten aus. Diesmal wird dabei jedoch auf die einzelnen Werte der im Array `@Daten` gespeicherten Liste zugegriffen. Mit `$Daten[0]` wird auf das erste Element der Liste zugegriffen, also auf den Wert `Jana`. Mit `$Daten[1]` auf das zweite Element, also `23` usw. Wichtig ist, dass bei 0 zu zählen begonnen wird. Die Zahl, die das nte. Element der Liste angibt, muss in eckigen Klammern stehen. Die Klammern gehören in diesem Kontext (innerhalb von Zeichenketten) zum Variablennamen und müssen direkt hinter dem Namen des Arrays notiert werden (kein Leerraum erlaubt).

Die Syntax wie in `$Daten[0]` zeigt mit dem voranstehenden Dollarzeichen, dass der Zugriff auf das Array-Element einen Skalar anfordert, denn Skalare sind immer an dem voranstehenden Dollarzeichen erkennbar.

### Beachten Sie:

Wenn Sie einen Array namens `@Daten` haben, können Sie mit der speziellen Notation `$#Daten` die höchste Indexnummer ermitteln, also die des letzten Listenelements, ohne zu wissen, wie viele Elemente die Liste hat. Angenommen, die Liste `@Daten` hat 15 Elemente: dann würde `$#Daten` den Wert 14 liefern. Mit einer Notation wie `$Daten[$#Daten]` können Sie dann den Wert des letzten Listenelements von `@Daten` ermitteln. Indem Sie negative Indexnummern verwenden, können Sie auf die Elemente am Ende des Arrays zugreifen. Dabei ist `$Daten[-1]` das letzte Element, `$Daten[-2]` das vorletzte usw.

## Mehrdimensionale Arrays

Wenn Sie andere Programmiersprachen kennen, sind Ihnen vielleicht schon mehrdimensionale Arrays begegnet. Dies sind Arrays, die Daten in matrixartiger Form speichern. Am einfachsten vorstellbar ist der zweidimensionale Array. Die darin gespeicherten Werte können Sie sich als Tabelle vorstellen. Um ein bestimmtes Element davon anzusprechen, geht man in eine bestimmte Tabellenzeile und von dort aus in eine bestimmte Spalte.

Perl kennt mehrdimensionale Arrays in diesem Sinne nicht, sondern nur Listen, die selbst wieder (Referenzen auf) Listen enthalten können. Dabei sind beliebig tiefe Verschachtelungen erlaubt. Stellen Sie sich jede Unterliste einer Liste als eine Dimension vor.

### Beispiel eines vollständigen CGI-Scripts:

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

    use strict;
    use CGI::Carp qw(fatalsToBrowser);

    my @Liste_1 = ("Baumholder","Bernried","Butzbach");
    my @Liste_2 = ("Berlin","Bremen",@Liste_1);
    my @Liste_3 = ("Berlin","Bremen",[@Liste_1]);

    print "Content-type: text/html\n\n";
    print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
    print "<html><head><title>Testausgabe</title>\n";
    print "</head><body>\n";

    print "<b>Liste_2:</b><pre>@Liste_2</pre>\n";
    print "<b>Liste_2[4]:</b><pre>$Liste_2[4]</pre>\n";

    print "<b>Liste_3</b><pre>@Liste_3</pre>";
    print "<b>Liste_3[2][1]:</b><pre>$Liste_3[2][1]</pre>\n";

    print "</body></html>\n";

### Erläuterung:

Im Beispiel werden insgesamt drei Listen deklariert und mit Anfangswerten initialisiert. Besonders interessant sind dabei die Listen `@Liste_2` und `@Liste_3`. Beide erhalten als jeweils letztes "Element" die komplette Liste `@Liste_1` zugewiesen (dabei zu beachten: der Array-Name darf nicht in Anführungszeichen stehen). Die Syntax ist dabei nur ganz leicht verschieden: in der Zuweisung bei `@Liste_2` ist einfach `@Liste_1` notiert, während in der Zuweisung bei `@Liste_3` noch eckige Klammern hinzukommen. Dort ist `[@Liste_1]` notiert. Dieser kleine Unterschied hat Folgen: während nämlich bei `@Liste_2` die Einzelwerte von `@Liste_1` einfach hinzugefügt werden, wird durch die eckigen Klammern bei `@Liste_3` eine neue Unterliste eröffnet.

Das Beispiel sendet HTML-Code an den aufrufenden Browser, in dem der Unterschied deutlich wird. `@Liste_2` besteht nun einfach aus fünf Elementen, nämlich `Berlin Bremen Baumholder Bernried Butzbach`. Eine Notation wie `$Liste_2[4]` greift auf das fünfte Element, also den Wert `Butzbach` zu. `Liste_3` besteht dagegen nunmehr aus drei Elementen, wobei das letzte Element nur eine neue Liste mit eigenen Elementen ist. Bei einer Anweisung wie `print "@Liste_3";` gibt Perl als drittes Element so etwas wie z.B. `ARRAY(0xb658ac)` aus. Das ist einfach eine Referenz auf die Unterliste. Um auf die Elemente der zweiten Dimension zuzugreifen, müssen Sie zweifache eckige Klammern verwenden, für jede Dimension eine. Eine Notation wie `$Liste_3[2][1]` greift über `[2]` auf das dritte Element von `@Liste_3` zu und dann noch einmal über `[1]` auf das zweite Unterelement dieses dritten Elements, das ja eine Liste ist. Zugegriffen wird im Beispiel also auf den Wert `Bernried`.

Das Beispiel zeigt auch, dass Sie in einer Liste beliebige einzelne Werte und weitere Listen mischen können. Auf das zweite Element der `Liste_3` greifen Sie mit `Liste_3[1]` zu. Die Angabe einer zweiten eckigen Klammer ist hier nicht notwendig, da das Element keine Unterliste ist.

### Beachten Sie:

Ob ein Array ein- oder mehrdimensional ist, also Unterlisten enthält, können Sie zu jedem Zeitpunkt festlegen. Wenn Sie beispielsweise mit der Anweisung `my @Tabelle;` einen zunächst undefinierten Array deklarieren, können Sie anschließend problemlos eine Anweisung wie `$Tabelle[1][4] = 27;` notieren. Damit erhält der Array `@Tabelle` automatisch zwei Elemente (mit den Nummern `0` und `1`). Element `0` erhält den undefinierten Wert (`undef`), und Element `1` bekommt die Referenz auf eine Liste mit fünf Elementen zugewiesen (`0` bis `4`), wovon die ersten vier Elemente den Wert `undef` erhalten und das fünfte Element den von Ihnen zugewiesenen Wert `27`.

## Funktionen und Operationen zum Manipulieren von Listen bzw. Arrays

Es gibt eine Menge Perl-Funktionen, mit deren Hilfe Sie Listen beeinflussen können. Ein paar wichtige Möglichkeiten sollen hier mit Verweisen auf die Beschreibung der jeweiligen Funktionen genannt werden.

Zeichenketten in Listen aufsplitten:
Wenn Sie Zeichenketten haben, die bestimmte regelmäßig vorkommende Zeichen enthalten, können Sie diese Zeichen als Trennzeichen behandeln und die Zeichenkette in eine Liste übertragen (z.B. kommagetrennte Werte). Dazu gibt es in Perl die Funktion split.

Listen zu einer Zeichenkette verknüpfen:
Manchmal möchte man auch den umgekehrten Weg gehen. Man hat Daten in einer Liste, möchte diese jedoch wieder als Zeichenkette zusammenfassen. Dazu gibt es in Perl die Funktion join.

Listenelemente ändern:
Durch eine Anweisung wie `$Liste[12] = "Oliver";` weisen Sie dem 13. Element der Liste einen Wert zu. Falls vorher schon ein Wert in diesem Element gespeichert war, wird er durch den neuen Wert ersetzt.

Listenelemente hinzufügen:
Zum Anhängen von Elementen an Listen bietet Perl die Funktionen push und unshift an.

Listenelemente löschen:
Sie können jederzeit so etwas notieren wie `$Liste[12] = "";`. Damit ist der Wert gelöscht (bzw. mit einer leeren Zeichenkette überschrieben), aber das Element besteht weiterhin. Richtig löschen können Sie eine Liste nur von vorne und von hinten. Um Elemente aus dem Array richtig zu entfernen, bietet Perl drei Funktionen an. Die Funktion pop löscht von hinten, also jeweils das letzte Element einer Liste. Die Funktion shift löscht von vorne, d.h. das erste Element wird gelöscht, und alle nachfolgenden rücken einen Indexwert nach vorne. Was also vorher `$Liste[7]` war, ist hinterher `$Liste[6]`. Die Funktion splice ermöglicht es, beliebige Elemente aus dem Array zu löschen, also sowohl von vorne wie auch von hinten oder auch aus der Mitte. Wie bei `shift` rücken dann die nachfolgenden Indexwerte entsprechend nach. Mit `splice` können Sie auch eine ganze Teilliste eines Arrays durch andere Liste ersetzen oder eine Liste in den Array neu einfügen.

Listenelemente sortieren und Reihenfolge umkehren:
Sie können eine Liste völlig neu organisieren, indem Sie deren Elemente numerisch oder alphabetisch sortieren. Perl bietet dazu die Funktion sort an. Eine dazu ergänzende interessante Funktion ist auch reverse, die Listenelemente einfach vertauscht. Das erste Element wird dadurch das letzte, das zweite das vorletzte usw. Durch Sortieren und anschließendes Anwenden von `reverse` kann man also beispielsweise eine absteigende Sortierung erreichen.

Anzahl Elemente einer Liste ermitteln:
Die Länge einer Liste lässt sich in Perl ganz einfach dadurch ermitteln, dass die Liste im skalaren Kontext interpretiert wird. Hört sich kompliziert an, ist aber ganz einfach. Ein Beispiel:
`my $Laenge = @Liste;`
Dabei wird im Skalar `$Laenge` die Anzahl der Elemente des Arrays `@Liste` gespeichert.

| Hashes (Variablen)
| Skalare (Variablen)

© 2007 Impressum