Diese Seiten sind Teil von Bachsau’s Archiv.
Die hier beschriebenen Praktiken entsprechen nicht mehr dem Stand der Technik!
Bitte nutzen Sie für aktuelle Projekte das fortlaufend aktualisierte SELFHTML-Wiki.

SELFHTML

Funktionen für Listen bzw. Arrays und Hashes

Informationsseite

nach unten Allgemeines zu diesen Funktionen
nach unten delete - Elementpaar aus Hash löschen
nach unten each - nächstes Elementpaar aus Hash ermitteln
nach unten exists - Ermitteln ob ein Hash-Name existiert
nach unten grep - Teilliste aus Liste durch Bedingung extrahieren
nach unten join - Liste in Zeichenkette verwandeln
nach unten keys - Alle Namen eines Hashes ermitteln
nach unten map - Befehle auf alle Listenelemente anwenden
nach unten pop - letztes Element eines Arrays löschen
nach unten push - Elemente an einen Array anhängen
nach unten reverse - Reihenfolge der Listenelemente umkehren
nach unten shift - erstes Element eines Arrays löschen
nach unten sort - Listenelemente sortieren
nach unten splice - Elemente innerhalb eines Arrays löschen, hinzufügen, ersetzen
nach unten undef - Wert aus Hash oder Array entfernen
nach unten unshift - Elemente am Anfang eines Arrays hinzufügen
nach unten values - Alle Werte eines Hashes ermitteln

 nach unten 

Allgemeines zu diesen Funktionen

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 Seite Listen und Seite Hashes behandelt.

nach obennach unten

delete - Elementpaar aus Hash löschen

Löscht ein beliebiges Elementpaar aus einem Hash. Im Gegensatz zur Funktion nach unten 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 undef, falls nichts gelöscht wurde.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

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 erzeugt, der alle Elementpaare enthält. Der Versuch, das nicht mehr existerende Element bgcolor auszugeben, erzeugt dabei einen Fehler.

Beachten Sie:

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 nach unten exists.

nach obennach unten

each - nächstes Elementpaar aus Hash ermitteln

Ermittelt das jeweils nächste Elementpaar eines Hashes und ist daher vor allem geeignet, 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.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/usr/bin/perl -w

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

my %EMail = ("Sender","tabaluga\@example.org",
          "Received","from smtp\@mailout.de",
          "Date", "Sat, 01 Apr 2000 01:45:35 +0200",
          "X-Mailer","Mozilla 4.72 [en] (WinNT; U)",
          "To","beispiel\@example.org",
          "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";

Erläuterung:

Das Beispiel definiert einen Hash mit Elementpaaren, die typische Kopfdaten einer E-Mail darstellen. Anschließend wird HTML-Code, in dem alle Elementpaare des Hashes zeilenweise ausgegeben werden, erzeugt. Dazu werden die Elementpaare in einer Seite 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@example.org). Das Beispiel gibt in jedem Schleifendurchlauf die ermittelten Daten zur Kontrolle aus.

nach obennach unten

exists - Ermitteln ob ein Hash-Name existiert

Ermittelt, ob ein Name in einem Hash vorkommt und wird daher normalerweise in Verbindung mit einer Seite if-Abfrage verwendet.

Erwartet als Parameter:
1. den Elementnamen.

Gibt true zurück, wenn der Elementname im Hash vorkommt.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

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 nach oben delete wird anschließend das gesamte Elementpaar für bgcolor gelöscht. Zur Kontrolle wird HTML-Code, der die Elementpaare enthält, erzeugt. 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 leerem Wert ausgegeben wird.

nach obennach unten

grep - Teilliste aus Liste durch Bedingung extrahieren

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.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/usr/bin/perl -w

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

opendir(DIR, "/var/www/selfhtml/dokumente");
my @Eintraege = readdir(DIR);
closedir(DIR);

chdir("/var/www/selfhtml/dokumente");

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";

Erläuterung:

Im Beispiel wird ein Verzeichnis eingelesen. Die Dateien werden in der Liste @Eintraege gespeichert (zum Einlesen von Dateien siehe Seite readdir). Anschließend wird mit Seite chdir in das zuvor eingelesene Verzeichnis gewechselt, weil der zweite der nachfolgenden grep-Aufrufe erfordert, dass das eingelesene Verzeichnis das aktuelle Verzeichnis ist.

Der 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 Seite 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 Seite 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 Seite Dateitestoperator -s zum Einsatz. Die gefundenen Dateien werden in der zurückgegebenen Liste @Grosse_Dateien gespeichert.

Das obige Beispiel gibt anschließend HTML-Code mit den beiden ermittelten Listen für HTML-Dateien und Dateien größer 50 Kilobyte aus.

nach obennach unten

join - Liste in Zeichenkette verwandeln

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.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

Das Beispiel erzeugt in einer Seite for-Schleife eine Liste namens @Werte. Darin werden alle Ergebnisse der Operationen von 21 bis 216 gespeichert (dazu dient der Seite 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 mit dem Ergebnis ausgegeben.

Beachten Sie:

Die Umkehrfunktion zum Erzeugen einer Liste aus einer Zeichenkette mit Trennzeichen und Werten ist Seite split.

nach obennach unten

keys - Alle Namen eines Hashes ermitteln

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.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

Das Beispiel ermittelt alle Namen des Seite vordefinierten Hashes %ENV in der Liste @Umgebungsvariablen. Zur Kontrolle wird HTML-Code erzeugt, in dem alle Umgebungsvariablen aufgelistet werden.

Beachten Sie:

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 nach unten values.

nach obennach unten

map - Befehle auf alle Listenelemente anwenden

Wendet Befehle auf alle Elemente einer Liste an. Praktisch, um eine Seite for- oder Seite 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 (das aktuelle Listenelement steht dann in Form der Variable $_ zur Verfügung).
2. die Liste, auf die der Befehl angewendet werden soll.

Gibt die bearbeitete Liste zurück.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

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 Seite lc auf alle Elemente der Liste angewendet, die eine Kleinschreibung aller Zeichen erzwingt. Zur Kontrolle gibt das Beispiel HTML-Code mit den Elementen der bearbeiteten Liste aus.

nach obennach unten

pop - letztes Element eines Arrays löschen

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.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

Das Beispiel definiert einen Satz und extrahiert alle einzelnen Zeichen daraus in einen Array (Erläuterung dazu siehe Funktion Seite substr). Das Beispiel erzeugt HTML-Code. Dabei wird in einer Seite 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.

nach obennach unten

push - Elemente an einen Array anhängen

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.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

Im Beispiel werden zwei Listen definiert: @Orte und @NeueOrte. In einer Seite foreach-Schleife werden die Elemente der Liste @NeueOrte der Reihe nach an die Liste @Orte angehängt. Mit Hilfe der Funktion nach unten sort wird die neue Liste mit allen Orten dann noch "asciibetisch" (nach der Reihenfolge der Zeichen in der ASCII-Codetabelle) sortiert. Das Beispiel gibt die gesamte neue Liste zur Kontrolle als HTML-Code aus.

nach obennach unten

reverse - Reihenfolge der Listenelemente umkehren

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.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

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 mit der bearbeiteten Liste ausgegeben.

Beachten Sie:

Die Funktion ist auch auf Seite 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.

nach obennach unten

shift - erstes Element eines Arrays löschen

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.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

Das Beispiel definiert einen Array, der die Namen unangenehmer seelischer Zustände auflistet. Innerhalb des HTML-Codes ist eine Seite 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 unangenehmen Seelenzustände noch herrschen. Bei jedem Schleifendurchgang wird aber die erste dieser Befindlichkeiten aus dem Array mit shift gelöscht. Dadurch wird der Array immer kleiner, und die Stimmung immer aufgehellter. Am Ende ist die Seelenwelt wieder in Ordnung. Dann wird auch die Schleife beendet, und es wird noch ein triumphierender Satz ausgegeben.

Beachten Sie:

Die Funktion shift wird in der Praxis auch gerne dazu verwendet, innerhalb von Subroutinen übergebene Parameter "abzuarbeiten". Ein Beispiel finden Sie im Abschnitt über Seite Subroutinen mit Parametern aufrufen.

nach obennach unten

sort - Listenelemente sortieren

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 in der ASCII-Codetabelle). Oder Sie erzwingen einen eigenen Sortier-Algorithmus. Dazu definieren Sie beispielsweise eine Seite 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, dass der Rückgabewert in einer anderen Liste gespeichert wird als in der Liste, die als Parameter übergeben wird.

Beispiel 1 eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

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ückgegebene Liste wird in der neuen Liste @Ordnung gespeichert. Zur Kontrolle wird HTML-Code mit der sortierten Liste ausgegeben.

Beispiel 2 eines vollständigen CGI-Scripts in Perl:

#!/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; }
}

Erläuterung:

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ückgegebene Liste wird im Beispiel in der neuen Liste @SortierteListe gespeichert. Zur Kontrolle wird HTML-Code mit der sortierten Liste ausgegeben.

Beachten Sie:

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 nach oben reverse auf die Liste anwenden.

nach obennach unten

splice - Elemente innerhalb eines Arrays löschen, hinzufügen, ersetzen

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, 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.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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>E-Mail-Adresse und Webadresse neu:</h2>\n";
splice(@Datensatz,2,0,"hdl\@example.org","http://www.example.org/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";

Erläuterung:

Im Beispiel wird ein Array namens @Datensatz definiert, der aus mehreren Elementen besteht. Das Script erzeugt HTML-Code und gibt den Array darin aus. Dabei wird der Array jedoch mehrfach mit splice manipuliert. Zunächst werden Elemente für E-Mail-Adresse 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 E-Mail-Adresse und Webadresse übergeben. Zur Kontrolle wird der Array dann erstmals ausgegeben. Er enthält zu diesem Zeitpunkt die Elemente:
Heinrich,Loewe,hdl@example.org,http://www.example.org/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@example.org,http://www.example.org/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 Perl-Interpreter 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, sodass 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@example.org,http://www.example.org/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 das Verwenden anderer Array-Funktionen:

Anweisung mit splice: entspricht folgender anderer Anweisung: siehe auch:
splice(@Array,@Array,0,"Element") push(@Array,"Element") nach oben push
splice(@Array,-1) pop(@Array) nach oben pop
splice(@Array,0,1) shift(@Array) nach oben shift
splice(@Array,0,0,"Element") unshift(@Array,"Element") nach unten unshift
 

nach obennach unten

undef - Wert aus Hash oder Array entfernen

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 wievielte 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.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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&auml;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";

Erläuterung:

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 bleiben 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 mit allen Daten ausgegeben. Die entfernten Elemente sind darin ebenfalls enthalten, weil sie noch vorhanden sind, jedoch ohne sichtbaren Wert. Stattdessen 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"; }.

Beachten Sie:

Um in einem Hash ein Elementpaar vollständig zu löschen, gibt es die Funktion nach oben delete. Um ein Element aus einem Array vollständig zu löschen, stehen die Funktionen nach oben pop, nach oben shift und nach oben splice zur Verfügung.

nach obennach unten

unshift - Elemente am Anfang eines Arrays hinzufügen

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 die vorne einzufügenden Elemente.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

Das Beispiel definiert einen Array mit drei WWW-Links, fertig notiert als HTML-Verweise. 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.

nach obennach unten

values - Alle Werte eines Hashes ermitteln

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.

Beispiel eines vollständigen CGI-Scripts in Perl:

#!/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";

Erläuterung:

Das Beispiel ermittelt mit values alle Werte des Seite vordefinierten Hashes %ENV in der Liste @Umgebungswerte. Mit Hilfe der Funktion nach oben 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 Seite 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: Seite Zeichenketten zusammenfügen). Diese neue Liste wird mit Hilfe der Funktion nach oben sort sortiert. Anschließend wird HTML-Code mit der sortierten Liste ausgegeben.

 nach oben
weiter Seite Funktionen für Berechnungen
zurück Seite Funktionen für Zeichenketten
 

© 2007 Seite Impressum

Originaladresse dieses Dokuments: http://de.selfhtml.org/perl/funktionen/listenhashes.htm