Perl/Funktionen für Listen bzw. Arrays und Hashes

Aus SELFHTML-Wiki
Wechseln zu: Navigation, Suche

Inhaltsverzeichnis

[Bearbeiten] 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.

[Bearbeiten] 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 undef, falls nichts gelöscht wurde.

Beispiel
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
my %hash=( a => "Wert A", b => "Wert B", c => "Wert C" );
 
my $return_1 = delete $hash{a};
 
my $return_2 = delete $hash{a};
   delete $hash{a} if exists hash{a};
 
my @slice = delete @hash{qw(b c)};
 
print <<"END";
Content-type:text/plain
 
Return 1 (erwartet "Wert A")    : $return_1 
Return 2 (erwartet undef)       : $return_2 
Slice (erwartet "Wert B,Wert C"): @slice
END
;
Das Beispiel definiert einen Hash mit drei Elementen.

Mit Hilfe der Funktion delete wird anschließend

  1. ein einzelnes Element gelöscht und der Rückgabewert gespeichert.
  2. das gleiche Element nochmals gelöscht und der Rückgabewert gespeichert. Hierbei sollte der Rückgabewert undef sein und einen Fehler erzeugen. Ein solcher Fehler lässt sich mit einer zusätzlichen exists-Abfrage vermeiden.
  3. ein Hashslice gelöscht und die Rückgabewerte in einem Array gespeichert.
Anschließend werden die Rückgabewerte zur Kontrolle ausgegeben. Der Rückgabewert von delete ist der Wert des gelöschten Hashelementes.
Beachten Sie: Sie können delete auch auf vordefinierte Hashes wie %ENV anwenden. Dabei werden die Umgebungsvariablen geändert.

Siehe auch http://perldoc.perl.org/functions/delete.html

[Bearbeiten] 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
#!/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"
    );
 
my $out;
while( my ($Name, $Wert) = each %EMail ){
   $out .= sprintf("%s: %s\n", $Name, $Wert );
}
 
print "Content-type: text/plain\n\n", $out;
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 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).

Siehe auch http://perldoc.perl.org/functions/each.html

[Bearbeiten] exists - Ermitteln ob ein Hash-Name 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
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
my %Angestellte =(
   name => "Mustermann",
   vorname => "Hans",
   geschlecht => "m",
   funktion => "Stellvertreter",
   abteilung => "Dokumentation",
   eintritt => "11.11.2011",
);
 
sub Vorstellungstext{
  my %Angestellter = @_;
 
  exists $Angestellter{austritt}
    and defined $Angestellter{austritt}
    and return undef;
 
  if(not exists $Angestellter{vorname}){
    $Angestellter{vorname} =
      ( $Angestellter{geschlecht} eq "m" ? "Herr" : "Frau" )
  }
  return sprintf("%s %s arbeitet seit dem %s als %s in der Abteilung %s.",
     $Angestellter{vorname},
     $Angestellter{name},
     $Angestellter{eintritt} || '(Datum unbekannt)',
     $Angestellter{funktion} || 'Reservist',
     $Angestellter{abteilung} || 'Aussendienst',
  );
}
 
my $report = Vorstellungstext(%Angestellter);
 
print "Content-type:text/plain\n\n";
$report and print $report,"\n";
Das Beispiel zeigt, wie Personaldaten aus einem Hash in einen Text eingebaut werden. Hierbei werden Bedingungen abgefragt.

exists $Angestellter{austritt} and defined $Angestellter{austritt} and return undef; bewirkt die Rückkehr aus der Subroutine, wenn ein definiertes Austrittsdatum vorliegt. Hierbei wird undef als Wert zurückgegeben.

if(not exists $Angestellter{vorname}){...} ergänzt dieses Hashelement mit einem geeigneten Eintrag entsprechend dem Geschlecht.

Zuletzt werden die Hashelemente in einen formatierten String eingebaut. Hierbei werden allenfalls fehlende Schlüssel noch alternativ mit Standardeinträgen versehen. Der formatierte Text wird zurückgegeben.

Im Anschluss wird die Subfunktion aufgerufen und im Erfolgsfall ausgegeben.

Der Text lautet: "Hans Mustermann arbeitet seit dem 11.11.2011 als Stellvertreter in der Abteilung Dokumentation."
Beachten Sie: Wenn Sie auf ein nicht existierendes Hashelement zugreifen, dann wird dieses erzeugt mit dem Wert undef.

Siehe auch http://perldoc.perl.org/functions/exists.html

[Bearbeiten] 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
#!/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");
 
# Extrahieren
my @HTML_Dateien = grep( m~\.x?htm~, @Eintraege);
my @Grosse_Dateien = grep(-s > 50 * 1024, @Eintraege);
 
# Ausgabe vorbereiten
my( $HTML_Dateien, $Grosse_Dateien);
 
foreach(@HTML_Dateien){
   $HTML_Dateien .= sprintf( "<li><a href='%s'>%s</a></li>\n", $_, $_ );
}
 
foreach(@Grosse_Dateien){
   $Grosse_Dateien .= sprintf( "<li><a href='%s'>%s</a></li>\n", $_, $_ );
}
 
print <<"END";
Content-type: text/html
 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head><title>Test</title></head><body>
<h2>HTML-Dateien im Verzeichnis</h2>
<ul> $HTML_Dateien </ul>
<h2>Dateien groesser 50KB im Verzeichnis</h2>
<ul> $Grosse_Dateien </ul>
</body></html>
END
;
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.

Der erste der beiden Aufrufe von grep ermittelt mittels dem regulären Ausdruck m~\.x?htm~ aus der eingelesenen Liste @Eintraege alle Einträge des Typs htm, html oder xhtml,also alle HTML-Dateien der Liste. Die gefundenen Dateien werden in der zurückgegebenen Liste @HTML_Dateien gespeichert.

Beim zweiten Aufruf wird eine vergleichende Bedingung, ähnlich wie man sie etwa aus bedingte Anweisungen mit if/unless/else/elsif kennt, angewendet. 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 gibt anschließend HTML-Code mit den beiden ermittelten Listen für HTML-Dateien und Dateien größer 50 Kilobyte aus.

Siehe auch http://perldoc.perl.org/functions/grep.html

[Bearbeiten] 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
#!/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 mit dem Ergebnis ausgegeben.
Beachten Sie: Die Umkehrfunktion zum Erzeugen einer Liste aus einer Zeichenkette mit Trennzeichen und Werten ist split.

Siehe auch http://perldoc.perl.org/functions/join.html

[Bearbeiten] 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
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
my $ausgabe;
foreach( sort keys %ENV ){
   $ausgabe .= sprintf( "<dt>%s</dt><dl>%s</dl>\n", $_, $ENV{$_} );
}
 
print <<"ENDE";
Content-type: text/html
 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head><title>Test-Ausgabe</title></head><body>
<h1>Umgebungsvariablen</h1>
<dt> $ausgabe </dt>
</body></html>
ENDE
Das Beispiel ermittelt alle Namen des vordefinierten Hashes %ENV in der Liste @Umgebungsvariablen. Dabei wird über die sortierte Liste aller Schlüssel des Hashes iteriert, um dann einen formatierten Ausgabestring zu erzeugen. Zur Kontrolle wird HTML-Code erzeugt, in dem alle Umgebungsvariablen aufgelistet werden.
Beachten Sie: Die Funktion, um nur die Werte, nicht die Namen eines Hashs zu ermitteln, ist values.

Siehe auch http://perldoc.perl.org/functions/keys.html

[Bearbeiten] 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 (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
#!/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 gibt das Beispiel HTML-Code mit den Elementen der bearbeiteten Liste aus.

[Bearbeiten] 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
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
my @Zeichen = split(//, "Was du heute kannst besorgen das verschiebe nicht auf morgen");
my $Spiegelverkehrt;
 
print "Content-type: text/html\n\n";
 
while(@Zeichen){
   print @Zeichen,"\n";
   $Spiegelverkehrt .= pop(@Zeichen);
}
 
print $Spiegelverkehrt, "\n";
Das Beispiel definiert einen Satz und splittet diesen an jedem Zeichen in einen Array.

In einer while-Schleife, wird einerseits der Array ausgegeben, dann aber das letztes Array-Element mit pop gelöscht. Da dieses Zeichen der Rückgabewert ist, wird es einem String angehängt. Die Schleife wird solange durchlaufen, wie @Zeichen nicht leer ist.

Zuletzt wird der spiegelverkehrte Satz nochmals ausgegeben.

Siehe auch http://perldoc.perl.org/functions/pop.html

[Bearbeiten] 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. ein oder mehrere anzuhängende Elemente.
Beispiel
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
my @Orte = qw(Wien Madrid Rom Stockholm Riga);
my @NeueOrte = qw(Bern Basel Genf);
 
push(@Orte, "London" );
push(@Orte, "Amsterdam", "Kairo" );
push(@Orte, qw(Paris Lissabon Sofia) );
push(@Orte, @NeueOrte );
 
@Orte = join("\n", sort(@Orte) );
 
print <<"ENDE";
Content-type: text/plain
 
@Orte
ENDE
Im Beispiel werden zwei Listen @Orte und @NeueOrte definiert.

Danach wird push mehrmals angewendet.

Mit Hilfe der Funktion sort wird die neue Ergebnis-Liste mit allen Orten dann noch "asciibetisch" (nach der Reihenfolge der Zeichen in der ASCII-Codetabelle) sortiert. und ausgegeben

Siehe auch http://perldoc.perl.org/functions/push.html

[Bearbeiten] reverse - Reihenfolge der Listenelemente umkehren

Im Listen-Kontext: 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.

Im Scalar-Kontext: Dreht die Zeichenfolge des ersten Arguments um.

Beispiel
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
my @Zahlen = qw(1 5 3 4 6 2 7);
my @Aufsteigend = sort { $a<=>$b } @Zahlen;
my @Absteigend = reverse( @Aufsteigend );
 
my $spiegelschrift = reverse( "Spiegelschrift" );
 
print <<"ENDE";
Content-type: text/plain
 
Aufsteigend sortiert: @Aufsteigend
Absteigend sortiert: @Absteigend
 
Aus "Spiegelschrift" wird "$spiegelschrift"
ENDE
Das Beispiel definiert eine Liste mit Zahlen von 1 bis 7.

Zuerst sortieren wir diesen Array aufsteigend von 1 bis 7.

Die umgekehrte Sortierung lässt sich durch reverse über die aufsteigende Liste realisieren.

Mit reverse können sie auch einen String spiegeln, so dass aus Spiegelschrift tfirhcslegeipS wird.
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.

Siehe auch http://perldoc.perl.org/functions/reverse.html

[Bearbeiten] 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
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
my @Zustaende = qw(Angst Melancholie Trauer Wut Zwiespalt Hass);
 
print "Content-type: text/plain\n\n";
 
while(@Zustaende) {
  print "Jetzt herrsch",
    (@Zustaende > 1?"en":"t"), " noch ", 
    join(', ',@Zustaende) ,"\n";
  shift(@Zustaende);
}
 
print "Und jetzt herrscht Friede!\n";
Das Beispiel definiert einen Array, der die Namen unangenehmer seelischer Zustände auflistet. Innerhalb des HTML-Codes ist eine while-Schleife notiert. Sie wird so oft durchlaufen, wie der ursprüngliche Array Elemente hat.

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 reduziert sich der Array um jeweils ein Element.

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

Siehe auch http://perldoc.perl.org/functions/shift.html

[Bearbeiten] 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 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
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
my @unsorted = qw( e c a b d );
 
my @sorted_default = sort(@unsorted);
my @sorted_compare = sort{$a cmp $b} @unsorted;
my @sorted_compare_reverse = sort{$b cmp $a} @unsorted;
my @sorted_default_reverse = reverse sort(@unsorted);
 
print
  @sorted_default,"\n",
  @sorted_compare,"\n",
  @sorted_compare_reverse,"\n",
  @sorted_default_reverse,"\n";
Dieses Beispiel zeigt die einfache standardmäßige Sortierung. Ausgangspunkt ist eine unsortierte Liste von Buchstaben.

Zuerst wird die Standardsortierung angewendet. Diese ist identisch mit dem zweiten Fall {$a cmp $b}. {$b cmp $a} dreht die Reihenfolge um. Dies ist identisch mit einem zusätzlichen reverse auf sort.

Die Standardsortierung ist die alphabetisch aufsteigende compare-Sortierung. Sie ist nicht geeignet zur Sortierung von numerischen Werten.
Beispiel
#!/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ü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 reverse auf die Liste anwenden.

[Bearbeiten] 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. ein bis n Elemente, die (anstelle der gelöschten Elemente) eingefügt werden sollen.

Gibt eine Liste mit gelöschten Elementen zurück.

Beispiel
#!/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";
! Anweisung mit splice

! entspricht folgender anderer Anweisung

! siehe auch

[Bearbeiten] undef - Wert aus Hash oder Array entfernen

Löscht den Wert eines Scalars, Hash- oder Arrayelements. 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.

Gibt in jedem Fall undef zurück.

Beispiel
#!/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");
 
# Wir resetten Fred
undef($Spielstaende{$Spieler[2]});
undef($Spieler[2]);
 
my $Teilnehmer;
 
foreach(@Spieler) {
   defined $_ and $Teilnehmer .= sprintf( "<li>%s</li>\n", $_ );
}
 
my $Spielstaende;
 
foreach( sort keys %Spielstaende ) {
  defined $Spielstaende{$_} 
     and $Spielstaende .= sprintf( "<li>%s: %5d Punkte</li>\n", $_ ,$Spielstaende{$_} );
}
 
print <<"ENDE";
Content-type: text/html
 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html><head><title>Test-Ausgabe</title></head><body>
<p>Folgende Spieler nehmen teil:</p>
<ul> $Teilnehmer </ul>
<p>Folgende Spielst&auml;nde sind aktuell:</p>
<ul> $Spielstaende </ul>
</body></html>
ENDE
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 Schlüssel Fred erhalten, nur dessen zugeordneter Wert 150 wird entfernt. "Entfernt" bedeutet in beiden Fällen, dass der Wert auf undef gesetzt wird.

Es werden nun Ausgaben vorbereitet. Während der Iteration über die Liste bzw. die Hash-Keys wird mit defined geprüft, ob das Element definiert ist. Würde ein undefiniertes Element zugewiesen, würde dies eine Fehlermeldung erzeugen.

Anschliessend erfolgt eine HTML-Ausgabe.
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.

Siehe auch http://perldoc.perl.org/functions/undef.html

[Bearbeiten] 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. das oder die vorne einzufügenden Elemente.
Beispiel
#!/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 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.

[Bearbeiten] 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
#!/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 mit der sortierten Liste ausgegeben.

[Bearbeiten] qw(Liste) Queryword Operator

Der qwOperator extrahiert aus einem String eine Liste von None-Whitespace-Worten.

Erwartet einen String Gibt eine Liste zurück.

Beispiel
#!/usr/bin/perl -w
 
use strict;
use CGI::Carp qw(fatalsToBrowser);
 
my @Tage = qw(
  Mo Montag 
  Di Dienstag
  Mi Mittwoch
  Do Donnerstag 
  Fr Freitag
  Sa Samstag
  So Sonntag
);
$Anzahl_Elemente = scalar @Tage;
 
my $out = "Abk. Name\n";
 
while( @Tage ){
  $out .= sprintf( "%2s:  %s\n", shift @Tage, shift @Tage);
}
 
print <<"ENDE";
Content-type:text/plain
 
Die Liste \@Tage enthält $Anzahl_Elemente Elemente
$out
ENDE
Mit dem qw-Operator wird eine Liste sparsam und nett formatiert erstellt.

Es wird die Anzahl der Elemente abgefragt und anschließend eine Liste erstellt, wobei das Array wie ein Hash behandelt wird.

Zur Kontrolle wird die Anzahl der Elemente (14) und die erzeugte Liste ausgegeben.

Siehe auch http://perldoc.perl.org/perlop.html#Quote-and-Quote-like-Operators

Meine Werkzeuge
Namensräume

Varianten
Aktionen
Übersicht
Schnell‑Index
Mitmachen
Werkzeuge
Spenden
SELFHTML