## Funktionen für Listen bzw. Arrays und Hashes

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

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

## delete - Elementpaar aus Hash löschen

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.

### 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 an den Browser gesendet, der alle Elementpaare ausgibt. 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 exists.

## each - nächstes Elementpaar aus Hash ermitteln

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.

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

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

### Erläuterung:

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.

## exists - Ermitteln ob ein Hash-Namen existiert

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.

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

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

### Erläuterung:

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.

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

### Beachten Sie:

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

## 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 vordefinierten Hashes `%ENV` in der Liste `@Umgebungsvariablen`. Zur Kontrolle wird HTML-Code an den Browser gesendet, 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 values.

## map - Befehle auf alle Listenelemente anwenden

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.

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

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

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

## 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 an den Browser gesendet, der die bearbeitete Liste ausgibt.

### Beachten Sie:

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.

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

### 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 Subroutinen mit Parametern aufrufen.

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

### 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ückgebene Liste wird in der neuen Liste `@Ordnung` gespeichert. Zur Kontrolle wird HTML-Code an den Browser gesendet, um die sortierte Liste auszugeben.

### 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ü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.

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

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

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

### Erläuterung:

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:

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

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

### 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 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"; }`.

### Beachten Sie:

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.

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

## 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 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

© 2001 selfhtml@teamone.de