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.
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";
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.
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.
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.
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";
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.
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.
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.
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";
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.
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.
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)
|
 SELFHTML/Navigationshilfen Perl Perl-Sprachelemente |
|
© 2007 Impressum