SELFHTML/Navigationshilfen CGI/Perl Perl-Funktionen| SELFHTML/Navigationshilfen CGI/Perl Perl-Funktionen |
 |
Funktionen für Listen bzw. Arrays und Hashes |
|
|
 | |
Um die hier versammelten Funktionen zu verstehen, müssen Sie wissen, welche Bedeutung Listen, Arrays und Hashes in Perl haben, wie sie definiert werden, und welche Besonderheiten sie aufweisen. Dies wird in den Abschnitten über 
Listen und Hashes behandelt.
|
Löscht ein beliebiges Elementpaar aus einem Hash. Im Gegensatz zur Funktion undef, die nur den Wert löscht, das Elementpaar jedoch stehen lässt, entfernt delete das gesamte Elementpaar.
Erwartet als Parameter:
1. den Schlüssel des zu löschenden Elementes.
Gibt den Wert des gelöschten Elementpaars zurück, oder undefined, falls nichts gelöscht wurde.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my %BodyFarben = ("text","#000000","link","#FF0000","alink","0000FF","vlink","#990000","bgcolor","#FFFFFF");
delete $BodyFarben{'bgcolor'};
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
print "text = $BodyFarben{'text'}<br>\n";
print "link = $BodyFarben{'link'}<br>\n";
print "alink = $BodyFarben{'alink'}<br>\n";
print "vlink = $BodyFarben{'vlink'}<br>\n";
print "bgcolor = $BodyFarben{'bgcolor'}\n";
print "</body></html>\n";
|
Das Beispiel definiert einen Hash namens %BodyFarben. Darin werden Elementpaare für die üblichen Attribute des body-Elements von HTML definiert. Mit Hilfe der Funktion delete wird anschließend das gesamte Elementpaar für bgcolor gelöscht. Zur Kontrolle wird HTML-Code an den Browser gesendet, der alle Elementpaare ausgibt. Der Versuch, das nicht mehr existerende Element bgcolor auszugeben, erzeugt dabei einen Fehler.
Sie können delete auch auf vordefinierte Hashes wie %ENV anwenden. Dabei werden die Umgebungsvariablen geändert!
Das obige Beispiel ist insofern unbefriedigend, als die Ausgabe bgcolor = leer im Raum stehen bleibt. Wie das verhindert werden kann, zeigt die Erweiterung des Beispiels im Zusammenhang mit der Funktion exists.
|
|
Ermittelt das jeweils nächste Elementpaar eines Hashes und ist daher vor allem geeignet, um alle Elementpaare in einer Schleife zu verarbeiten.
Erwartet als Parameter:
1. den Hash.
Gibt je nach Wunsch entweder eine 2-Element-Liste mit dem Namen und dem Wert des nächsten Elementpaars zurück, oder einen Skalar mit dem Namen des nächsten Elementpaars.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my %EMail = ("Sender","tabaluga\@drachen.net",
"Received","from smtp\@mailout.de",
"Date", "Sat, 01 Apr 2000 01:45:35 +0200",
"X-Mailer","Mozilla 4.72 [en] (WinNT; U)",
"To","selfhtml\@teamone.de",
"Content-Type","text/plain; charset=us-ascii");
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body><pre>\n";
while (my ($Name, $Wert) = each %EMail) {
print "$Name: $Wert\n";
}
print "</pre></body></html>\n";
|
Das Beispiel definiert einen Hash mit Elementpaaren, die typische Kopfdaten einer E-Mail darstellen. Das Beispiel sendet anschließend HTML-Code an den Browser, in dem alle Elementpaare des Hashes zeilenweise ausgegeben werden. Dazu werden die Elementpaare in einer while-Schleife mit each abgearbeitet. Der Rückgabewert von each wird im Beispiel in einer 2-Element-Liste my ($Name, $Wert) gespeichert. Würde dort nur ein Skalar stehen, also etwa $NextElement, dann würde darin nur der Name des nächsten Elements gespeichert, also etwa Sender, nicht der zugehörige Wert (tabaluga@drachen.net). Das Beispiel gibt in jedem Schleifendurchlauf die die ermittelten Daten zur Kontrolle aus.
|
|
Ermittelt, ob ein Name in einem Hash vorkommt und wird daher normalerweise in Verbindung mit einer if-Abfrage verwendet.
Erwartet als Parameter:
1. den Elementnamen.
Gibt true zurück, wenn der Elementname im Hash vorkommt.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my %BodyFarben = ("text","#000000","link","#FF0000","alink","0000FF","vlink","#990000","bgcolor","#FFFFFF");
delete $BodyFarben{'bgcolor'};
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
print "text = $BodyFarben{'text'}<br>\n" if exists $BodyFarben{'text'};
print "link = $BodyFarben{'link'}<br>\n" if exists $BodyFarben{'link'};
print "alink = $BodyFarben{'alink'}<br>\n" if exists $BodyFarben{'alink'};
print "vlink = $BodyFarben{'vlink'}<br>\n" if exists $BodyFarben{'vlink'};
print "bgcolor = $BodyFarben{'bgcolor'}\n" if exists $BodyFarben{'bgcolor'};
print "</body></html>\n";
|
Das Beispiel definiert einen Hash namens %BodyFarben. Darin werden Elementpaare für die üblichen Attribute des body-Elements von HTML definiert. Mit Hilfe der Funktion delete wird anschließend das gesamte Elementpaar für bgcolor gelöscht. Zur Kontrolle wird HTML-Code an den Browser gesendet, der die Elementpaare ausgibt. Ausgegeben werden Elementpaare jedoch nur, wenn sie existieren. Dazu wird die Funktion exists in einer nachgestellten if-Abfrage auf das auszugebende Elementpaar angewendet. Nur wenn der Name des Elementpaars gefunden wird, werden die Daten ausgegeben. Im Beispiel wird auf diese Weise verhindert, dass die Zeile bgcolor = mit leerstehenem Wert ausgegeben wird.
|
|
Extrahiert bestimmte Elemente aus einer Liste, und zwar solche, die einer bestimmten Bedingung genügen, also etwa alle ungeraden Zahlen aus einer Liste mit Zahlen, oder alle Dateien ab einer bestimmten Größe aus einer Liste mit Dateien. Die extrahierten Elemente werden in einer eigenen, neuen Liste gespeichert.
Erwartet als Parameter:
1. die Bedingung, der zu extrahierende Elemente der Liste genügen sollen. Es kann sich beispielsweise um einen regulären Ausdruck handeln, aber auch um einen vergleichenden Ausdruck.
2. die Liste, aus der extrahiert werden soll.
Gibt eine Liste mit extrahierten Elementen zurück, die der Bedingung genügen.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
opendir(DIR, "/usr/texte/artikel");
my @Eintraege = readdir(DIR);
closedir(DIR);
chdir("/usr/texte/artikel");
my @HTML_Dateien = grep(/\.htm/,@Eintraege);
my @Grosse_Dateien = grep(-s > 50 * 1024, @Eintraege);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test</title></head><body>\n";
print "<h2>HTML-Dateien im Verzeichnis</h2>\n";
foreach(@HTML_Dateien) {
print "$_<br>\n";
}
print "<h2>Dateien groesser 50KB im Verzeichnis</h2>\n";
foreach(@Grosse_Dateien) {
print "$_<br>\n";
}
print "</body></html>\n";
|
Im Beispiel wird ein Verzeichnis eingelesen. Die Dateien werden in der Liste @Eintraege gespeichert (zum Einlesen von Dateien siehe readdir). Anschließend wird mit chdir in das zuvor eingelesene Verzeichnis gewechselt, weil der zweite der nachfolgenden grep-Aufrufe erfordert, dass das eingelesene Verzeichnis das aktuelle Verzeichnis ist.
Die erste der beiden Aufrufe von grep ermittelt aus der eingelesenen Liste @Eintraege alle Einträge, in denen .htm vorkommt. Auf diese Weise ermittelt grep alle HTML-Dateien der Liste. Die gefundenen Dateien werden in der zurückgegebenen Liste @HTML_Dateien gespeichert.
Während beim ersten Aufruf von grep ein regulärer Ausdruck verwendet wird, um die Extrahier-Bedingung zu formulieren, ist dies beim zweiten Aufruf eine vergleichende Bedingung, ähnlich wie man sie etwa aus bedingte Anweisungen mit if/unless/else/elsif kennt. Im Beispiel werden alle Einträge extrahiert, bei denen die Dateigröße mehr als 50 Kilobyte (50*1024 Byte) beträgt. Dabei kommt der Dateitestoperator -s zum Einsatz. Die gefundenen Dateien werden in der zurückgegebenen Liste @Grosse_Dateien gespeichert.
Das obige Beispiel sendet anschließend HTML-Code an den Browser und gibt die beiden ermittelten Listen für HTML-Dateien und Dateien größer 50 Kilobyte aus.
|
|
Bindet die Elemente einer Liste zu einer Zeichenkette zusammen. In der Zeichenkette werden die ehemaligen Listenelemente durch ein bestimmtes Zeichen oder eine bestimmte Zeichenfolge voneinander getrennt.
Erwartet als Parameter:
1. das Zeichen oder die Zeichenfolge, die zur Trennung der Listenelemente dienen soll,
2. die Liste.
Gibt eine Zeichenkette zurück, in der alle Elemente der übergebenen Liste nacheinander notiert sind, getrennt durch das angegebene Zeichen oder die Zeichenfolge zur Trennung.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Werte;
for(my $i=0; $i<16; $i++) {
$Werte[$i] = 2 ** ($i+1);
}
my $Wertekette = join(";",@Werte);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
print "$Wertekette\n";
print "</body></html>\n";
|
Das Beispiel erzeugt in einer for-Schleife eine Liste namens @Werte. Darin werden alle Ergebnisse der Operationen von 21 bis 216 gespeichert (dazu dient der Berechnungsoperator **). Anschließend wird diese Liste der Funktion join übergeben. Als Trennzeichen wird ein Semikolon (;) bestimmt. Das Ergebnis wird in dem Skalar $Wertekette gespeichert, einer einfachen Zeichenkette. Zur Kontrolle wird HTML-Code an den Browser gesendet, der das Ergebnis ausgibt.
Die Umkehrfunktion zum Erzeugen einer Liste aus einer Zeichenkette mit Trennzeichen und Werten ist split.
|
|
Speichert alle Namen von Elementpaaren eines Hashes in einer Liste.
Erwartet als Parameter:
1. den Hash.
Gibt eine Liste mit den Namen der Elementpaare zurück.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Umgebungsvariablen = keys(%ENV);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
print "<p>Folgende Umgebungsvariablen sind definiert:</p>\n";
print "<ul>\n";
foreach(@Umgebungsvariablen) {
print "<li>$_</li>\n";
}
print "</ul>\n";
print "</body></html>\n";
|
Das Beispiel ermittelt alle Namen des vordefinierten Hashes %ENV in der Liste @Umgebungsvariablen. Zur Kontrolle wird HTML-Code an den Browser gesendet, in dem alle Umgebungsvariablen aufgelistet werden.
In dem Beispiel werden nur die Namen der vorhandenen Umgebungsvariablen aufgelistet, nicht deren aktuelle Werte! Die Funktion, um nur die Werte, nicht die Namen eines Hashs zu ermitteln, ist values.
|
|
Wendet Befehle auf alle Elemente einer Liste an. Praktisch, um eine for- oder foreach-Schleife zu vermeiden.
Erwartet als Parameter:
1. einen Befehl, der auf alle Listenelemente angewendet werden soll. Es kann sich um eine Funktion handeln, aber auch um eine ganze Folge von Anweisungen, die dann zu einem Block zusammengefasst werden.
2. die Liste, auf die der Befehl angewendet werden soll.
Gibt die bearbeitete Liste zurück.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Dateien = ("Index.htm","ACDC.html","acdc.jpg","oasis.htm","Oasis.jpg");
@Dateien = map(lc, @Dateien);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
foreach(@Dateien) {
print "$_<br>\n";
}
print "</body></html>\n";
|
Im Beispiel wird eine Liste mit Dateinamen definiert. Die Dateinamen enthalten zum Teil auch Großbuchstaben. Anschließend wird die Funktion map auf die Liste angewendet. Dabei wird die Funktion lc auf alle Elemente der Liste angewendet, die eine Kleinschreibung aller Zeichen erzwingt. Zur Kontrolle sendet das Beispiel HTML-Code an den Browser und gibt dabei die Elemente der bearbeiteten Liste aus.
|
|
Entfernt aus einem Array das letzte Element. Der Array wird um ein Element verkürzt.
Erwartet als Parameter:
1. den Array.
Gibt das gelöschte Element zurück.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my $Satz = "Was du heute kannst besorgen das verschiebe nicht auf morgen";
my $Satzlaenge = length($Satz);
my @Zeichen;
for(my $i=0;$i<$Satzlaenge;$i++) {
$Zeichen[$i] = substr($Satz,$i,1);
}
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
for(my $i=0; $i<$Satzlaenge; $i++) {
print "@Zeichen<br>\n";
pop(@Zeichen);
}
print "</body></html>\n";
|
Das Beispiel definiert einen Satz und extrahiert alle einzelnen Zeichen daraus in einen Array (Erläuterung dazu siehe Funktion substr). Das Beispiel sendet HTML-Code an den Browser. Dabei wird in einer for-Schleife, die so oft durchlaufen wird, wie die Anzahl Zeichen im ursprünglichen Satz beträgt, jeweils der gesamte Array @Zeichen ausgegeben. Der Array wird jedoch bei jedem Schleifendurchgang mit Hilfe der Funktion pop um das letzte Element verkürzt. So wird bei jedem Schleifendurchgang jeweils ein Zeichen des Satzes weniger ausgegeben.
|
|
Fügt ein oder mehrere neue Elemente an das Ende eines Arrays an.
Erwartet als Parameter:
1. den Array, an den das Element angehängt werden soll,
2. bis n. ein oder mehrere anzuhängende Elemente.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Orte = ("Wien","Madrid","Rom","Stockholm","Riga");
my @NeueOrte = ("Paris","Lissabon","Sofia");
foreach(@NeueOrte) {
push(@Orte,$_);
}
@Orte = sort(@Orte);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
foreach(@Orte) {
print "$_<br>\n";
}
print "</body></html>\n";
|
Im Beispiel werden zwei Listen definiert: @Orte und @NeueOrte. In einer foreach-Schleife werden die Elemente der Liste @NeueOrte der Reihe nach an die Liste @Orte angehängt. Mit Hilfe der Funktion sort wird die neue Liste mit allen Orten dann noch "asciibetisch" (nach der Reihenfolge der Zeichen im ASCII-Zeichensatz) sortiert. Das Beispiel sendet HTML-Code an den Browser, wobei die gesamte neue Liste zur Kontrolle ausgegeben wird.
|
|
Dreht eine Liste so um, dass das erste Element hinterher das letzte ist, das zweite das zweitletzte usw.
Erwartet als Parameter:
1. die gewünschte Liste.
Gibt die bearbeitete Liste zurück.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Zahlen = (1..100);
@Zahlen = reverse(@Zahlen);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
foreach(@Zahlen) {
print "$_<br>\n";
}
print "</body></html>\n";
|
Das Beispiel definiert eine Liste mit Zahlen von 1 bis 100. Anschließend wird die Funktion reverse auf die Liste angewendet, sodass darin die Elemente von 100 bis 1 gespeichert sind. Zur Kontrolle wird HTML-Code an den Browser gesendet, der die bearbeitete Liste ausgibt.
Die Funktion ist auch auf Hashes anwendbar. Beispiel:
%Mailheader = reverse(%Mailheader);
Dabei werden die Schlüssel und Werte der Elemente miteinander vertauscht. Dies ist jedoch dann problematisch, wenn ein Hash mehrere gleiche Werte besitzt. In diesem Fall wird im bearbeiteten Hash nur noch einer der Werte (der nun als Schlüssel dient) berücksichtigt.
|
|
Entfernt das erste Element eines Arrays. Das zweite ist anschließend das erste usw. Der Array wird um ein Element kürzer.
Erwartet als Parameter:
1. den zu bearbeitenden Array.
Gibt das gelöschte Element zurück.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Zustaende = ("Angst, ","Melancholie, ","Trauer, ","Wut, ","Zwiespalt, ","Hass");
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
my $max = @Zustaende;
for(my $i = 0; $i < $max; $i++) {
print "<p>jetzt herrscht noch @Zustaende<br>\n";
shift(@Zustaende);
}
print "<p>und jetzt herrscht Friede!</p>\n";
print "</body></html>\n";
|
Das Beispiel definiert einen Array mit unschönen Zuständen. Innerhalb des HTML-Codes, der an den Browser gesendet wird, ist eine for-Schleife notiert. Sie wird so oft durchlaufen, wie der ursprüngliche Array Elemente hat. Dazu wird die Länge der Liste in dem Skalar $max gespeichert. Bei jedem Schleifendurchgang wird ausgegeben, welche der unschönen Zustände noch herrschen. Bei jedem Schleifendurchgang wird aber der erste der Zustände in dem Array mit shift gelöscht. Dadurch wird der Array immer kleiner, und die Zustände weniger. Am Ende ist keiner mehr vorhanden. Dann wird auch die Schleife beendet, und es wird noch ein triumphierender Satz ausgegeben.
Die Funktion shift wird in der Praxis auch gerne dazu verwendet, innerhalb von Subroutinen übergebene Parameter "abzuarbeiten". Ein Beispiel finden Sie im Abschnitt über Subroutinen mit Parametern aufrufen.
|
|
Sortiert die Elemente einer Liste. Dabei gibt es zwei Möglichkeiten. Entweder Sie sortieren die Liste nach dem vorgegebenen Sortier-Algorithmus. Dieser sortiert alphabetisch, genauer gesagt, "asciibetisch" (nach der Reihenfolge der Zeichen im ASCII-Zeichensatz). Oder Sie erzwingen einen eigenen Sortier-Algorithmus. Dazu definieren Sie beispielsweise eine Subroutine, die den entsprechenden Algorithmus leistet. Wichtig ist dies etwa, um Listenelemente numerisch zu sortieren.
Erwartet als Parameter:
entweder:
1. die zu sortierende Liste.
oder:
1. die Anweisung oder den Namen der Subroutine mit dem Sortier-Algorithmus,
2. die zu sortierende Liste.
Gibt die sortierte Liste zurück. Wichtig ist jedoch, dass der Rückgabewert in einer anderen Liste gespeichert wird als in der Liste, die als Parameter übergeben wird.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Freundinnen = ("Nina","Martina","Janina","Christina","Ina","Sabrina");
my @Ordnung = sort(@Freundinnen);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
for(@Ordnung)
{
print "$_<br>\n";
}
print "</body></html>\n";
|
Dieses Beispiel zeigt die einfache, standardmäßige Sortierung. Es definiert eine Liste von Namen von Freundinnen. Anschließend wird die Liste mit Hilfe von sort sortiert. Die zurückgebene Liste wird in der neuen Liste @Ordnung gespeichert. Zur Kontrolle wird HTML-Code an den Browser gesendet, um die sortierte Liste auszugeben.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @HighscoreListe = (9834,9837,5989,4509,4329,6509,2837,8289,10845);
my @SortierteListe = sort(NummernSort @HighscoreListe);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
for(@SortierteListe) {
print "$_<br>\n";
}
print "</body></html>\n";
sub NummernSort {
if($a < $b)
{ return -1; }
elsif($a == $b)
{ return 0; }
else
{ return 1; }
}
|
Das zweite Beispiel definiert eine Liste namens @HighscoreListe. Anschließend wird die Liste mit Hilfe von sort sortiert. Da es sich um numerische Werte handelt, wird eine Funktion benutzt, die den numerischen Sortier-Algorithmus bereitstellt. Denn "asciibetisch" betrachtet würde der letzte Wert 10845 in der aufsteigend sortierten Liste zuerst erscheinen, was er aber nicht soll, da er ja der höchste Wert ist, der zuletzt auftauchen soll. Dem Aufruf von sort wird deswegen zuerst der Name des Unterprogramms für die Sortierung übergeben, und dann, durch ein Leerzeichen getrennt (nicht durch Komma!), die zu sortierende Liste. Die zurückgebene Liste wird im Beispiel in der neuen Liste @SortierteListe gespeichert. Zur Kontrolle wird HTML-Code an den Browser gesendet, der die sortierte Liste ausgibt.
Das im Beispiel notierte Unterprogramm NummernSort ist allgemein geschrieben und leistet eine einfache numerische Sortierung, so, wie es die sort-Funktion erwartet. Dieses Unterprogramm können Sie also immer verwenden, wenn Sie Listen numerisch sortieren möchten.
Um eine absteigende Sortierung zu erzwingen, können Sie beispielsweise nach Anwendung von sort noch die Funktion reverse auf die Liste anwenden.
|
|
Entfernt eines oder mehrere Elemente aus einem Array und kann außerdem an der gleichen Stelle eines oder mehrere Elemente einfügen. splice ist daher eine Art Universalfunktion zur Manipulation von Listen, die unter anderem alles ermöglicht, was die Einzelfunktionen pop, push, shift und unshift leisten, und darüber hinaus aber noch mehr kann.
Erwartet als Parameter:
1. den zu bearbeitenden Array,
2. Indexnummer des Elements, ab dem gelöscht werden soll (wobei bei 0 für das erste Listenelement zu zählen begonnen wird),
3. (optional) Anzahl der zu löschenden Elemente. Wenn nicht angegeben, werden alle Elemente bis zum Listenende gelöscht! Um kein Element zu löschen, also nur einzufügen, muss an dieser Stelle 0 übergeben werden.
4. bis n. (optional) ein bis n Elemente, die (anstelle der gelöschten Elemente) eingefügt werden sollen.
Gibt eine Liste mit gelöschten Elementen zurück.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Datensatz = ("Heinrich","Loewe","Burgstr.1","01234 Regentenstadt");
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test</title></head><body>\n";
print "<h2>Mailadresse und Webadresse neu:</h2>\n";
splice(@Datensatz,2,0,"hdl\@mittelalter.net","http://www.mittelalter.net/hdl/");
my $Feld;
foreach $Feld (@Datensatz) {
print "$Feld<br>\n";
}
print "<h2>Adresse neu:</h2>\n";
splice(@Datensatz,4,1);
splice(@Datensatz,-1,1,"Postfach 1234, GERMANY");
foreach $Feld (@Datensatz) {
print "$Feld<br>\n";
}
print "</body></html>\n";
|
Im Beispiel wird ein Array namens @Datensatz definiert, der aus mehreren Elementen besteht. An den Browser wird HTML-Code gesendet und der Array dabei ausgegeben. Der Array wird dabei jedoch mehrfach mit splice manipuliert. Zunächst werden Elemente für Mailadresse und Webadresse in den Datensatz eingefügt - und zwar hinter den beiden ersten Elementen, also hinter Vorname und Zuname. Dazu wird als zweiter Parameter die Indexnummer 2 für das dritte Element übergeben. Gelöscht werden soll kein Element, die Daten sollen nur eingefügt werden. Deshalb wird als dritter Parameter 0 übergeben. Zuletzt werden noch die beiden neuen Elemente für Mailadresse und Webadresse übergeben. Zur Kontrolle wird der Array dann erstmals ausgegeben. Sie besteht zu diesem Zeitpunkt aus den Elementen:
Heinrich,Loewe,hdl@mittelalter.net,http://www.mittelalter.net/hdl/,Burgstr.1,01234 Regentenstadt
Der Array wird im Beispiel jedoch noch weiter manipuliert. Zunächst wird das Element mit der Indexnummer 4 (im aktuellen Stand von @Datensatz die Straßenangabe) gelöscht. Die als dritter Parameter übergebene 1 bewirkt, dass genau dieses eine Element gelöscht wird. @Datensatz besteht zu diesem Zeitpunkt aus den Elementen:
Heinrich,Loewe,hdl@mittelalter.net,http://www.mittelalter.net/hdl/,01234 Regentenstadt
Gleich anschließend folgt im Beispiel jedoch noch ein dritter splice-Aufruf. Dieser ersetzt das letzte Listenelement durch ein neues. Als zweiter Parameter wird zu diesem Zweck -1 übergeben. Da der Perlinterpreter bei negativen Indexnummern von hinten anfängt zu zählen, entspricht -1 also der letzten Indexnummer, -2 der vorletzten usw. Als dritter Parameter wird 1 übergeben, so dass dieses letzte Element gelöscht wird. Zuletzt wird jedoch noch ein weiterer Parameter übergeben, nämlich das zu ersetzende Element. So entsteht der Effekt, als ob einfach dem letzten Listenelement ein neuer Wert zugewiesen wird. Intern passiert jedoch mehr.
Der Array hat nach dem dritten Aufruf von splice folgendes Aussehen:
Er besteht zu diesem Zeitpunkt aus den Elementen:
Heinrich,Loewe,hdl@mittelalter.net,http://www.mittelalter.net/hdl/,Postfach 1234, GERMANY.
Zur Kontrolle wird dieser Stand noch einmal ausgegeben.
Die folgende Tabelle zeigt zur Verdeutlichung noch ein paar splice-Beispiele und deren Entsprechung durch Verwenden anderer Array-Funktionen:
|
|
|
Löscht einen Wert aus einem Hash oder einem Array. Das Element selbst bleibt dabei erhalten. Der Wert wird lediglich auf den Wert undef gesetzt.
Erwartet als Parameter:
1. bei einem Hash den Elementnamen, und bei einem Array die Angabe dazu, das wie vielte Element gemeint ist. Kann daneben auch auf einfache Skalare und Unterprogramme angewendet werden, um deren Wert oder Rückgabewert auf undef zu setzen.
Gibt in jedem Fall undef zurück.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Spieler = ("Richard","Anita","Fred","Miriam");
my %Spielstaende = ("Richard","350","Anita","400","Fred","150","Miriam","700");
undef($Spieler[2]);
undef($Spielstaende{'Fred'});
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
print "<p>Folgende Spieler nehmen teil:</p>\n";
print "<ul>\n";
foreach(@Spieler) {
print "<li>$_</li>\n";
}
print "</ul>\n";
print "<p>Folgende Spielstände sind aktuell:</p>\n";
print "<ul>\n";
my @Namen = keys(%Spielstaende);
foreach(@Namen) {
print "<li>$_: $Spielstaende{$_} Punkte</li>\n";
}
print "</ul>\n";
print "</body></html>\n";
|
Das Beispiel definiert einen Array namens @Spieler und einen Hash namens %Spielstaende. Der Spieler Fred, der sich aus dem Spiel ausklinkt, wird aus beiden Datenstrukturen mit undef entfernt. Dabei bleibt jedoch das Array-Element für Fred und das entsprechende Elementpaar im Hash erhalten. Im Array wird durch undef der Wert, also der Name entfernt, und im Hash bleibt der Name Fred erhalten, nur dessen zugeordneter Wert 100 wird entfernt. "Entfernt" bedeutet in beiden Fällen, dass der Wert auf undef gesetzt wird. Zur Kontrolle wird im Beispiel HTML-Code an den Browser gesendet, der alle Daten ausgibt. Die entfernten Elemente werden ausgegeben, weil sie noch vorhanden sind, jedoch ohne sichtbaren Wert. Statt dessen erfolgt beim Zugriff auf diese Elemente eine Fehlermeldung. Der Wert undef bedeutet, dass der entsprechende Skalar oder das entsprechende Element (noch) keinen Wert besitzt. Es ist "undefiniert". Es kann jedoch auf undef hin abgefragt werden. Beispiel:
unless (defined $Spielstaende{'Fred'}) { print "Fred ist ausgestiegen"; }.
Um in einem Hash ein Elementpaar vollständig zu löschen, gibt es die Funktion delete. Um ein Element aus einem Array vollständig zu löschen, stehen die Funktionen pop, shift und splice zur Verfügung.
|
|
Fügt ein oder mehrere neue Elemente am Anfang eines Arrays an. Der Array wird entsprechend länger.
Erwartet als Parameter:
1. den gewünschten Array,
2. bis n. das oder vorne einzufügenden Elemente.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Links=("<a href=\"http://www.willy-online.de/\">willy-online.de</a><br>\n",
"<a href=\"http://www.suedelbien.de/\">suedelbien.de</a><br>\n",
"<a href=\"http://www.sagmal.de/\">sagmal.de</a><br>\n");
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test</title></head><body>\n";
unshift(@Links,"<a href=\"http://www.ganze-kerle.de/\">ganze-kerle.de</a><br>\n");
print "@Links";
print "</body></html>\n";
|
Das Beispiel definiert ein Array mit drei WWW-Links, fertig notiert als HTML-Verweise. An den Browser wird HTML-Code gesendet. Bevor der Array mit den Links ausgegeben wird, wird dem Array mit unshift vorne ein neues Element angefügt. Anschließend wird der gesamte Array mit nunmehr vier Verweisen ausgegeben, wobei der hinzugefügte Verweis der erste ist.
|
|
Speichert alle Werte von Elementpaaren eines Hashes in einer Liste.
Erwartet als Parameter:
1. den Hash.
Gibt eine Liste mit den Werten der Elementpaare zurück.
#!/usr/bin/perl -w
use strict;
use CGI::Carp qw(fatalsToBrowser);
my @Umgebungswerte = values(%ENV);
my @Umgebungsvariablen = keys(%ENV);
my @Umgebung;
for(my $i=0; $i < @Umgebungswerte; $i++) {
$Umgebung[$i] = $Umgebungsvariablen[$i]." = ".$Umgebungswerte[$i];
}
@Umgebung = sort(@Umgebung);
print "Content-type: text/html\n\n";
print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
print "<html><head><title>Test-Ausgabe</title></head><body>\n";
print "<p>Folgende Umgebungswerte sind definiert:</p>\n";
print "<ul>\n";
foreach(@Umgebung) {
print "<li>$_</li>\n";
}
print "</ul>\n";
print "</body></html>\n";
|
Das Beispiel ermittelt mit values alle Werte des vordefinierten Hashes %ENV in der Liste @Umgebungswerte. Mit Hilfe der Funktion keys wird eine entsprechende Liste @Umgebungsvariablen für die Elementnamen des Hashes erzeugt. Anschließend wird eine neue Liste @Umgebung erzeugt. In dieser Liste werden die beiden separaten Listen für die Namen und Werte in einer for-Schleife zusammengeführt. Jeder Listeneintrag der Liste @Umgebung besteht aus dem jeweiligen Namen einer Umgebungsvariablen, einem Gleichheitszeichen und dem zugehörigen Wert (siehe auch: Zeichenketten zusammenfügen). Diese neue Liste wird mit Hilfe der Funktion sort sortiert. Anschließend wird HTML-Code an den Browser gesendet, der die sortierte Liste ausgibt.
|
| |
 |
Funktionen für Berechnungen
|
 |
Funktionen für Zeichenketten
|
| SELFHTML/Navigationshilfen CGI/Perl Perl-Funktionen |
© 2001 
selfhtml@teamone.de