# Funktionen für Zeichenketten

Allgemeines zu diesen Funktionen
chomp - letztes Zeichen entfernen, sofern Separator
chop - letztes Zeichen entfernen
chr - Zeichen eines Zeichenwerts ermitteln
crypt - Zeichenkette verschlüsseln
index - erstes Vorkommen einer Teilzeichenkette in Zeichenkette suchen
lc - alle Zeichen einer Zeichenkette in Kleinbuchstaben umwandeln
lcfirst - erstes Zeichen einer Zeichenkette in Kleinbuchstabe umwandeln
length - Anzahl Zeichen einer Zeichenkette ermitteln
ord - Zeichenwert eines Zeichens ermitteln
pack - Binärdaten erzeugen
pos - Position der Anwendung von `m/[regexp]/g` auf Zeichenkette ermitteln
reverse - Zeichenkette von hinten nach vorn umwandeln
split - Zeichenkette in mehrere Zeichenketten aufsplitten
sprintf - Zeichenkette formatieren
substr - Teilzeichenkette aus Zeichenkette extrahieren
uc - alle Zeichen einer Zeichenkette in Großbuchstaben umwandeln
ucfirst - erstes Zeichen einer Zeichenkette in Großbuchstabe umwandeln
unpack - Binärdaten auflösen

## Allgemeines zu diesen Funktionen

Um die hier versammelten Funktionen zu verstehen, sollten Sie die allgemeinen Bemerkungen zu Zeichenketten in Perl kennen.

## chomp - letztes Zeichen entfernen, sofern Separator

Entfernt das letzte Zeichen aus einer Zeichenkette. Das kann vor allem bei der Weiterverarbeitung von Zeichenketten interessant sein, die ein Endekennzeichen haben, in der Regel ein Newline-Zeichen `\n`. Im Gegensatz zu der Funktion chop, die in jedem Fall das letzte Zeichen entfernt, egal um was es sich handelt, entfernt die Funktion `chomp` nur solche Zeichen, die in der vordefinierten Variablen `$/` enthalten sind. Per Voreinstellung ist in dieser Variablen nur das Newline-Zeichen `\n` gespeichert. Sollte eine Zeichenkette also nicht mit diesem Sonderzeichen enden, passiert bei Anwendung von `chomp` im Gegensatz zu `chop` gar nichts.

Erwartet als Parameter:
1. die Liste von Zeichenketten, auf welche die Funktion angewendet werden soll. Statt einer Liste kann auch eine einzelne Zeichenkette bzw. ein Skalar mit einer Zeichenkette übergeben werden.

Gibt die Anzahl der Zeichen zurück, die insgesamt entfernt wurden.

### Beispiel - Teil 1 (Datei boot.ini):

    [boot loader]
    timeout=30
    default=multi(0)disk(0)rdisk(0)partition(1)\WINNT
    [operating systems]
    multi(0)disk(0)rdisk(0)partition(1)\WINNT="Microsoft Windows XP Professional" /fastdetect

### Beispiel - Teil 2 (vollständiges CGI-Script in Perl):

    #!C:/Programme/Perl/bin/perl.exe -w

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

    open(BOOTINI, "<c:/boot.ini") || die "Fehler aufgetreten: $!";
    my @Zeilen = <BOOTINI>;
    close(BOOTINI);
    chomp(@Zeilen);

    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 "<pre>\n";
    print "@Zeilen";
    print "</pre>\n";
    print "</body></html>\n";

### Erläuterung:

Das Beispiel zeigt im ersten Teil eine typische zeilenweise Textdatei, hier eine boot.ini, wie man sie auf NT-basierten Windows-Systemen (von Windows NT bis Windows XP) vorfindet. Im CGI-Script des Beispiels wird die Datei in den Array `@Zeilen` eingelesen. Anschließend wird die Funktion `chomp` auf den Array `@Zeilen` angewendet. Dadurch wird von jeder Zeile das beendende Newline-Zeichen entfernt. Zur Kontrolle gibt das Script am Ende HTML-Code aus. Innerhalb eines `<pre>`-Bereichs, in dem alles so ausgegeben wird, wie es notiert ist, wird die Liste `@Zeilen` ausgegeben. Da alle Newline-Zeichen entfernt wurden, erscheinen die Einträge der Liste nicht mehr als separate Zeilen, sondern in einer druchgehenden Zeichenfolge.

### Beachten Sie:

In diesem Beispiel wird davon ausgegangen, dass Sie das Script auf einem Windows-Rechner einsetzen wollen. Aus diesem Grund muss auch die erste Zeile des Perl-Scripts einen Pfad zum Perl-Interpreter aufweisen, der auf einem Windows-System gütig ist.

## chop - letztes Zeichen entfernen

Entfernt das letzte Zeichen aus einer Zeichenkette. Im Gegensatz zu chomp entfernt `chop` in jedem Fall das letzte Zeichen, egal, worum es sich handelt.

Erwartet als Parameter:
1. eine Variable, auf die die Funktion angewendet werden soll. Alternativ kann auch eine Liste übergeben werden. Wird eine Liste übergeben, gibt `chop` das abgeschnittene Zeichen des letzen Listenelementes zurück.

Gibt das abgeschnittene Zeichen zurück.

## chr - Zeichen eines Zeichenwerts ermitteln

Ermittelt zu einem numerischen Wert das zugehörige Zeichen. Darstellbar sind größtenteils allerdings nur die Zeichen mit Zeichenwerten höher als 32, da die darunterliegenden Zeichen so genannte Steuerzeichen sind, die in der Regel nicht am Bildschirm darstellbar sind.
Die Gegenfunktion ist ord.

Erwartet als Parameter:
1. den gewünschten Zeichenwert als Zahl.

Gibt das zugehörige Zeichen zurück.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    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 "<table border=\"1\" bgcolor=\"#FFFFE0\">\n";
    my $Zeichenwert = 0;
    my $ASCII_Zeichen = "";
    for(my $i=0;$i<16;$i++) {
       print "<tr>\n";
       for(my $j=0;$j<8;$j++) {
          $ASCII_Zeichen = chr($Zeichenwert);
          print "<td>$Zeichenwert = $ASCII_Zeichen</td>\n";
          $Zeichenwert++;
       }
       print "</tr>\n";
    }
    print "</table>\n";
    print "</body></html>\n";

### Erläuterung:

Das Beispiel erstellt in zwei ineinander verschachtelten for-Schleifen eine HTML-Tabelle mit 16 Zeilen zu je 8 Spalten. In jeder der dadurch entstehenden 128 Zellen wird ein ASCII-Zeichen und dessen Zeichenwert ausgegeben. Dazu wird jeweils vor dem Schreiben der aktuellen Tabellenzelle die Funktion `chr` auf den aktuellen Stand des Skalars `$Zeichenwert` angewendet, der bei jedem inneren Schleifendurchgang um 1 erhöht wird und durch die beiden Schleifen der Reihe nach alle Zahlen zwischen 0 und 127 annimmt. Der Rückgabewert, also das ASCII-Zeichen, wird jeweils in dem Skalar `$ASCII_Zeichen` gespeichert. Beide Skalare werden in jeder Tabellenzelle ausgegeben, sodass die Zuordnung zwischen Zeichenwert und ASCII-Codetabelle deutlich wird.

## crypt - Zeichenkette verschlüsseln

Mit dieser Funktion können Sie eine Zeichenkette verschlüsseln. Dazu wird die Zeichenkette selbst sowie eine zweite Zeichenkette benötigt, die als "Salz in der Suppe" (engl. salt) dient.
Die Funktion `crypt` leistet nur eine einseitige Verschlüsselung. Eine entsprechende Entschlüsselungsmethode ist nicht bekannt. `crypt` ist daher nicht geeignet, um Kodier- und Dekodierverfahren zu realisieren.
`crypt` entspricht dem gleichnamigen Systemprogramm unter Unix und der gleichnamigen Funktion in C. Im Zusammenhang mit Web-Seiten wird `crypt` beispielsweise beim Verzeichnisschutz mit .htaccess verwendet, um die Passwörter berechtigter Zugänge verschlüsselt zu speichern.

Erwartet als Parameter:
1. die Zeichenkette, die verschlüsselt werden soll.
2. das "Salz in der Suppe", eine Zeichenkette, die aus zwei frei wählbaren Zeichen bestehen sollte.

Gibt die verschlüsselte Zeichenkette zurück.

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

Anzeigebeispiel: So sieht's aus - mit dem string "Stefan+kn" als Übergabeparameter
(Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my $Input = $ENV{'QUERY_STRING'};
    my ($String, $Salt) = split(/\+/,$Input);
    my $CryptString = crypt($String,$Salt);

    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 "die Zeichenkette <b>$String</b> lautet verschl&uuml;sselt: <b>$CryptString</b>\n";
    print "</body></html>\n";

### Erläuterung:

Das Beispiel-CGI-Script erwartet einen Übergabeparameter, der beim Aufruf über URI hinter einem Fragezeichen notiert wird. Der Übergabeparameter besteht aus der zu verschlüsselnden Zeichenkette und dem "Salz in der Suppe", getrennt durch ein Pluszeichen. Beispiel:
http://localhost/cgi-bin/test.pl?Stefan+kn.

Das Beispiel-Script ermittelt den übergebenen Parameter aus der CGI-Umgebungsvariablen `QUERY_STRING` und speichert den Wert im Skalar `$input`. Um den Übergabeparameter am Pluszeichen aufzusplitten (hier also die zu verschlüsselnde Zeichenkette und das "Salz in der Suppe" voneinander zu trennen), wird die Funktion split eingesetzt, die das Ergebnis in einer aus den beiden Skalaren `$String` und `$Salt` bestehenden Liste speichert. Anschließend wird die Funktion `crypt` angewendet, der die beiden Skalare als Parameter übergeben werden. Der Rückgabewert, also die verschlüsselte Zeichenkette, wird in dem Skalar `$CryptString` gespeichert. Zur Kontrolle gibt das Script die zu verschlüsselnde Zeichenkette und das Ergebnis der Verschlüsselung aus.

### Beachten Sie:

`crypt` kann nur Zeichenketten mit maximal 8 Zeichen Länge verschlüsseln. Sollte die Zeichenkette länger sein, werden nur die ersten 8 Zeichen verschlüsselt.

## index - erstes Vorkommen einer Teilzeichenkette in Zeichenkette suchen

Diese Funktion sucht in einer Zeichenkette nach einer beliebigen Teilzeichenkette, jedoch ohne reguläre Ausdrücke. Sie können also beispielsweise in einer Textzeile nach `Sex-Appeal` suchen, aber nicht nach `Sex.*`.

Erwartet als Parameter:
1. die Zeichenkette, in der gesucht werden soll,
2. die Zeichenkette, nach der gesucht werden soll,
3. (optional) die Zeichenposition, ab der gesucht werden soll, z.b. 8 für "ab dem 9. Zeichen". Wenn Sie den 3. Parameter weglassen, wird ab dem Beginn der Zeichenkette gesucht.

Gibt die Position des Zeichens zurück, an dem die gewünschte Teilzeichenkette gefunden wurde. Wenn sie nicht gefunden wurde, wird `-1` zurückgegeben.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my $Satz = "in diesem Satz ist von Liebe die Rede.";

    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";
    if(index($Satz,"Liebe") >= 0) {
      print "in diesem Satz ist von Liebe die Rede\n";
    }
    else {
      print "in diesem Satz ist leider nicht von Liebe die Rede\n";
    }
    print "</body></html>\n";

### Erläuterung:

Das Beispiel definiert einen Skalar namens `$Satz` und weist ihm einen Wert zu. Das Script gibt HTML-Code aus. Mit der `index`-Funktion ermittelt es, ob in dem Skalar `$Satz` von Liebe die Rede ist. Dies ist der Fall, wenn der Rückgabewert der Funktion größer/gleich 0 ist. Im obigen Beispiel gelangt das Script in den if-Zweig, weil in dem durchsuchten Satz von Liebe die Rede ist.

## lc - alle Zeichen einer Zeichenkette in Kleinbuchstaben umwandeln

Wandelt Großbuchstaben in Kleinbuchstaben um und lässt Kleinbuchstaben und alle anderen Zeichen unberührt. Die entsprechende Gegenfunktion für Großbuchstaben ist uc.

Erwartet als Parameter:
1. die Zeichenkette, die bearbeitet werden soll.

Gibt die bearbeitete Zeichenkette zurück.

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

    #!C:/Programme/Perl/bin/perl.exe -w

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

    opendir(DIR, "C:/WINNT");
    my @Eintraege = readdir(DIR);
    closedir(DIR);
    foreach my $Eintrag (@Eintraege) {
      $Eintrag = lc($Eintrag);
      $Eintrag = $Eintrag."\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-Ausgabe</title></head><body>\n";
    print "<pre>\n";
    print "@Eintraege";
    print "</pre>\n";
    print "</body></html>\n";

### Erläuterung:

Das Beispiel liest das auf PCs mit Betriebssystem Windows übliche Windows-Verzeichnis ein (Die entsprechenden Befehle dazu sind opendir, readdir) und closedir. In diesem Verzeichnis befinden sich normalerweise jede Menge Dateien und Unterverzeichnisse, die achtlos Groß- und Kleinschreibung enthalten, zum Teil auch, weil sie zu alten 16-Bit-Programmen gehören. Auf jedes Element des Arrays `@Eintraege`, in den der Inhalt des Verzeichnisses eingelesen wurde, wird anschließend in einer for-Schleife die Funktion `lc` angewendet. Der Rückgabewert wird in der gleichen aktuellen Schleifenvariable `$Eintrag` gespeichert, die auch als zu bearbeitende Zeichenkette übergeben wird.
Das Anhängen eines Newline-Zeichens innerhalb der gleichen `for`-Schleife ist nur für die folgende Ausgabe gedacht. Die Ausgabe erzeugt die gesamte eingelesene und bearbeitete Liste der Verzeichniseinträge. Alle Einträge enthalten nur noch Kleinbuchstaben.

### Beachten Sie:

In diesem Beispiel wird davon ausgegangen, dass Sie das Script auf einem Windows-Rechner einsetzen wollen. Aus diesem Grund muss auch die erste Zeile des Perl-Scripts einen Pfad zum Perl-Interpreter aufweisen, der auf einem Windows-System gütig ist.

## lcfirst - erstes Zeichen einer Zeichenkette in Kleinbuchstabe umwandeln

Wandelt das erste Zeichen einer Zeichenkette in Kleinbuchstaben um, sofern es ein entsprechender Großbuchstabe ist. Die entsprechende Gegenfunktion für Großbuchstaben ist ucfirst.

Erwartet als Parameter:
1. die Zeichenkette, die bearbeitet werden soll.

Gibt die bearbeitete Zeichenkette zurück.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    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 $Wort = "Textart";
    print lcfirst($Wort);
    print "</body></html>\n";

### Erläuterung:

Das Beispiel gibt nur ein Wort aus. Bevor das Wort ausgegeben wird, wird allerdings die Funktion `lcfirst` darauf angewendet. Der führende Großbuchstabe wird dabei in einen Kleinbuchstaben verwandelt.

## length - Anzahl Zeichen einer Zeichenkette ermitteln

Erwartet als Parameter:
1. die gewünschte Zeichenkette.

Gibt die Anzahl Zeichen in der Zeichenkette zurück.

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

Anzeigebeispiel: So sieht's aus - ohne Übergabeparameter
Anzeigebeispiel: So sieht's aus - mit dem String "http://www.selfhtml.org" als Übergabeparameter
(Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my $URI = $ENV{'QUERY_STRING'};
    my $Laenge = length($URI);

    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 "<a href=\"$URI\">$URI</a> hat eine Länge von $Laenge Zeichen!\n";
    print "</body></html>\n";

### Erläuterung:

Das Beispiel-CGI-Script erwartet einen Übergabeparameter, der beim Aufruf über URI hinter einem Fragezeichen notiert wird. Der Übergabeparameter sollte selber einen URI enthalten. Beispiel:
http://localhost/cgi-bin/test.pl?http://www.selfhtml.org/.

Das Beispiel ermittelt mit `length` die Länge der übergebenen Adresse und gibt HTML-Code mit einem Link auf die Adresse mit Angabe der Zeichenzahl aus.

## ord - Zeichenwert eines Zeichens ermitteln

Ermittelt zu einem Zeichen den zugehörigen Wert zwischen 0 und 127. Die Gegenfunktion ist chr.

Erwartet als Parameter:
1. das gewünschte Zeichen.

Gibt den zugehörigen Zeichenwert zurück.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my $MagischeZahl = "155";
    my $Laenge = length($MagischeZahl);
    my $Quersumme = 0;
    for(my $i=0; $i<$Laenge; $i++) {
       my $Zeichen = substr($MagischeZahl, $i, 1);
       $Quersumme = $Quersumme + int(ord($Zeichen));
    }

    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 "Die Quersumme der ASCII-Werte der Zeichen der Zahl $MagischeZahl beträgt $Quersumme\n";
    print "</body></html>\n";

### Erläuterung:

Das Beispiel definiert eine "magische Zahl" 155. "Magisch" ist diese Zahl deshalb, weil sie aus den Zeichen "1", "5" und nochmal "5" besteht, und weil die Summe der Zeichenwerte dieser drei Zeichen 155 ergibt. Denn die 1 hat den Zeichenwert 49, und die 5 hat den Zeichenwert 53, und 49+53+53 ergibt 155. In einer for-Schleife wird die Zahl Ziffer für Ziffer eingelesen. Das geht in Perl mit Hilfe der Funktion substr. Auf das jeweils eingelesene Zeichen wird die Funktion `ord` angewendet. Ihr Rückgabewert, also der Zeichenwert des verarbeiteten Zeichens, wird bei jedem Schleifendurchgang zu dem bisherigen Wert des Skalars `$Quersumme` hinzuaddiert. Das Script gibt zur Kontrolle ein entsprechendes Ergebnis als HTML-Code aus.

## pack - Binärdaten erzeugen

Erzeugt eine binäre Datenstruktur aus einem oder mehreren Werten. Der Daten-Input kann selbst eine Zeichenkette, aber etwa auch eine Liste sein. Eine zusätzliche Formatierungsangabe dient dazu, das binäre Datenformat des zu erzeugenden Ergebnisses der Konvertierung genau zu steuern. Für die Formatierungsangabe steht eine spezielle Syntax zur Verfügung.
Die Funktion `pack` wird beispielsweise verwendet, um einer Datenbank Zeichenketten zu übergeben, innerhalb deren die Datenbank feste Feldlängen erwartet. Aber auch andere mächtige Konvertierarbeiten sind möglich. So lassen sich Daten mit Hilfe von `pack` etwa sehr einfach nach dem UUencode-Verfahren kodieren.

Erwartet als Parameter:
1. die Formatierungsangabe,
2. den Daten-Input - eine Zeichenkette oder eine Liste.

Gibt den erzeugten Wert zurück.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my @Datensatz_1 = ("Anna","Lyse","07.07.1977","w","Bau 21", "Zi 280","seit 03/1999 Team-Assistenz Marketing");
    my @Datensatz_2 = ("Rainer","Zufall","29.02.1960","m","Bau 113", "Zi 11","Bereichsleiter Entwicklung");
    my $Format = "A10 A14 A10 A1 A7 A7 A*";
    my $Ausgabe_1 = pack($Format, @Datensatz_1);
    my $Ausgabe_2 = pack($Format, @Datensatz_2);

    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 "<pre>\n";
    print "$Ausgabe_1\n";
    print "$Ausgabe_2\n";
    print "</pre>\n";
    print "</body></html>\n";

### Erläuterung:

In dem Beispiel werden zunächst zwei Listen `@Datensatz_1` und `@Datensatz_2` mit gleichartigen Mitarbeiterdaten definiert. Die Felder eines Datensatzes sollen jeweils zu einer Zeichenkette verbunden werden, sodass sich diese beispielsweise als Zeile am Bildschirm ausgeben oder in eine Datei schreiben lässt. Dabei sollen jedoch die Felder immer an der gleichen Spaltenposition beginnen, so wie in der Ergebnisausgabe dargestellt. Um das zu erreichen, wird eine Zeichenkette namens `$Format` definiert. Sie definiert die Feldbreiten der einzelnen Datenfelder. Dazu benutzt sie die spezielle Syntax für `pack`-Formatierangaben. Weiter unten finden Sie eine Tabelle der Formatierangaben. Im Beispiel wird für das erste Feld (Vorname) mit `A10` eine Breite von 10 Zeichen definiert, für das zweite Feld (Nachname) mit `A14` eine Breite von 14 Zeichen, und so weiter für die übrigen Datenfelder. Das letzte Feld, die beschreibende Angabe, wird durch das Sternchen bei `A*` als "so breit wie der Inhalt des Feldes ist" definiert.
Anschließend wird zweimal die Funktion `pack` angewendet, einmal auf `@Datensatz_1` und dann auf `@Datensatz_2`. In beiden Fällen wird die gleiche Formatierangabe, also `$Format`, benutzt. Der Räckgabewert wird in den Zeichenketten `$Ausgabe_1` bzw. `$Ausgabe_2` gespeichert. Diese beiden Zeichenketten werden zur Kontrolle als HTML-Ausgabe zum Browser gesendet. Wichtig ist dabei, die Ausgabe in einen `<pre>`-Bereich zu setzen, da nur dort die Spaltendarstellung sichtbar wird.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my $Satz = "In Münchner Biergärten gibt es Bier nur aus Maßkrügen";
    my $UUE_Satz = pack("u", $Satz);

    print "Content-type: text/plain\n\n";
    print "Der Satz '$Satz' lautet UU-kodiert:\n$UUE_Satz";

### Erläuterung:

Das Beispiel definiert einen Satz in dem Skalar `$Satz`. Auf diesen Skalar wird die Funktion `pack` angewendet. Als Formatierangabe wird dabei `u` übergeben. Dies bewirkt eine Kodierung nach dem UUencode-Verfahren. Das Ergebnis wird in dem neuen Skalar `$UUE_Satz` gespeichert. Zur Kontrolle wird ein entsprechender Text an den Browser gesendet. Der Beispielsatz erscheint in der UUencode-Kodierung als `M26X@3?QN8VAN97(@0FEE<F?D<G1E ;B!G:6)T(&5S($)I97(@;G5R(&%U<R!- (8=]K<OQG96X``.

### Tabelle der Formatierangaben:

Durch die Formatierangabe steuern Sie die Art, wie `pack` den Daten-Input behandelt.

Typ: | Bedeutung: | Beispiel: | Erläuterung:
--- | --- | --- | ---

`a[n]`

Erzeugt einen String aus 8-Bit-Zeichen und ist auch für binäre Daten geeignet. `[n]` ist eine Zahl für die Feldbreite. Ungenutzte Bytes werden mit Zeichenwert 0 (Hex-0) aufgefüllt. Überbreite Feldinhalte werden abgeschnitten. Anstelle einer Zahl ist auch `*` erlaubt. Dadurch richtet sich die Feldbreite nach dem Feldinhalt.

`@Mitarbeiter = ("03919","Hinkel");
$Ausgabe = pack("a5 a15", @Mitarbeiter);`

Ein Mitarbeiterdatensatz, bestehend aus einer Ausweisnummer und dem Namen, wird in eine Zeichenkette verwandelt.

`A[n]`

Erzeugt ASCII-Zeichen (Zeichenwerte 0-127) und ist daher für Textdaten geeignet. `[n]` ist eine Zahl für die Feldbreite. Ungenutzte Bytes werden mit Leerzeichen (Zeichenwert 32) aufgefüllt. Ansonsten wie `a`.

`$Ausgabe = pack("A80", "kleine Zeile");`

Erzeugt wird eine Zeichenkette von 80 Zeichen Breite, auch wenn der Textinhalt deutlich kleiner ist. Die restlichen Zeichen sind Leerzeichen.

`Z[n]`

Erzeugt ASCII-Zeichen (Zeichenwerte 0-127) und ist daher für Textdaten geeignet. `[n]` ist eine Zahl für die Feldbreite. Ungenutzte Bytes werden mit Zeichenwert 0 (Hex-0) aufgefüllt. Außerdem wird der String in jedem Fall nullterminiert, d.h. das letzte Zeichen hat immer den Zeichenwert 0 (Hex-0). Ansonsten wie `A`.

`$Ausgabe = pack("A80", "kleine Zeile");`

Erzeugt wird eine Zeichenkette von 80 Zeichen Breite, auch wenn der Textinhalt deutlich kleiner ist. Die restlichen Zeichen haben den Wert hexadezimal 0.

`b[n]` | Erzeugt einen Bit-String in aufsteigender Bitreihenfolge. Das letzte Bit jedes Bytes der Eingabe ergibt ein Bit der Ausgabe. Dabei wird das letzte 8-bit Tupel gegebenenfalls mit Nullen aufgefüllt. | `$Ausgabe = pack("b8","Beispiel")` | Erzeugt eine Zeichenkette von 8 Bit, also einem Byte Länge
`B[n]` | Erzeugt einen Bit-String in absteigender Bitreihenfolge. Arbeitet genauso wie `b`, dreht aber die Reihenfolge um. | ``$Ausgabe = pack("B8","Beispiel")`` | Erzeugt eine Zeichenkette von 8 Bit, also einem Byte Länge

`c[n]`

Erzeugt Zeichen aus numerischen Angaben. Das kleine c steht für signed char, verarbeitet werden 8 Bit lange Ganzzahlen zwischen -128 und 127. `[n]` ist eine Zahl für die Anzahl Zeichen. Wenn Sie mehrere Zeichen auf einmal verarbeiten wollen, geben Sie die Anzahl der Zeichen an. Anstelle einer Zahl ist auch `*` erlaubt. Benutzen Sie den Platzhalter, wenn Sie eine unbestimmte Anzahl Zeichen verarbeiten wollen.

`@Zeichenwerte = (65,115,116,114,105,100);
$Ausgabe = pack("c6", @Zeichenwerte);
print "$Ausgabe";`

Das Beispiel erzeugt eine Liste aus 6 Zahlen. Mit `c6` werden alle 6 Zahlen in ihre Zeichenwerte (gemäß der ASCII-Codetabelle) umgewandelt und in der Zeichenkette `$Ausgabe` zusammengefügt.

`C[n]` | Erzeugt Zeichen aus numerischen Angaben. Das große C steht für unsigned char, verarbeitet werden 8 Bit lange Ganzzahlen ohne Vorzeichen, also zwischen 0 und 255. Ansonsten wie `c`. | `@Zeichenwerte = (65,115,116,114,105,100); $Ausgabe = pack("C6", @Zeichenwerte); print "$Ausgabe";` | siehe Erläuterung zu `c`.

`s[n]`

Erzeugt Zeichen aus numerischen Angaben. Das kleine s steht für signed short. Verarbeitet werden dabei in Perl 16 Bit lange Ganzzahlen zwischen -32768 und 32767. Ansonsten wie `c`.

`@Werte = (-1000,1000);
$Ausgabe = pack("s2", @Werte);
print "$Ausgabe";`

Das Beispiel erzeugt eine Liste aus 2 Zahlen. Mit `s2` werden die Zahlen in Zeichen oder Zeichenkombinationen umgewandelt und in der Zeichenkette `$Ausgabe` zusammengefügt.

`S[n]`

Erzeugt Zeichen aus numerischen Angaben. Das große S steht für unsigned short. Verarbeitet werden dabei in Perl 16 Bit lange Ganzzahlen zwischen 0 und 65535. Ansonsten wie `s`.

`@Werte = (1,1000);
$Ausgabe = pack("S2", @Werte);
print "$Ausgabe";`

Das Beispiel erzeugt eine Liste aus 2 Zahlen. Mit `S2` werden die Zahlen in Zeichen oder Zeichenkombinationen umgewandelt und in der Zeichenkette `$Ausgabe` zusammengefügt.

`i[n]`

Erzeugt Zeichen aus numerischen Angaben. Das kleine i steht für signed integer. Verarbeitet werden dabei in Perl mindestens 32 Bit lange Ganzzahlen zwischen -2147483648 und 2147483647 (je nach Umgebung werden auch höhere Bitlängen und damit größere Zahlen verarbeitet). Ansonsten wie `c`.

`@Werte = (-100000,100000);
$Ausgabe = pack("i2", @Werte);
print "$Ausgabe";`

Das Beispiel erzeugt eine Liste aus 2 großen Zahlen. Mit `i2` werden die Zahlen in Zeichen oder Zeichenkombinationen umgewandelt und in der Zeichenkette `$Ausgabe` zusammengefügt.

`I[n]`

Erzeugt Zeichen aus numerischen Angaben. Das große I steht für unsigned integer. Verarbeitet werden dabei in Perl mindestens 32 Bit lange Ganzzahlen zwischen 0 und 4294967296 5 (je nach Umgebung werden auch höhere Bitlängen und damit größere Zahlen verarbeitet). Ansonsten wie `i`.

`@Werte = (1,100000);
$Ausgabe = pack("I2", @Werte);
print "$Ausgabe";`

Das Beispiel erzeugt eine Liste aus 2 Zahlen. Mit `I2` werden die Zahlen in Zeichen oder Zeichenkombinationen umgewandelt und in der Zeichenkette `$Ausgabe` zusammengefügt.

`l[n]`

Erzeugt Zeichen aus numerischen Angaben. Das kleine l steht für signed long. Verarbeitet werden dabei in Perl genau 32 Bit lange Ganzzahlen zwischen -2147483648 und 2147483647. Ansonsten wie `c`.

`@Werte = (-100000,100000);
$Ausgabe = pack("l2", @Werte);
print "$Ausgabe";`

Das Beispiel erzeugt eine Liste aus 2 großen Zahlen. Mit `l2` werden die Zahlen in Zeichen oder Zeichenkombinationen umgewandelt und in der Zeichenkette `$Ausgabe` zusammengefügt.

`L[n]`

Erzeugt Zeichen aus numerischen Angaben. Das große L steht für unsigned long. Verarbeitet werden dabei in Perl genau 32 Bit lange Ganzzahlen zwischen 0 und 4294967295. Ansonsten wie `l`.

`@Werte = (1,100000);
$Ausgabe = pack("L2", @Werte);
print "$Ausgabe";`

Das Beispiel erzeugt eine Liste aus 2 Zahlen. Mit `L2` werden die Zahlen in Zeichen oder Zeichenkombinationen umgewandelt und in der Zeichenkette `$Ausgabe` zusammengefügt.

`n[n]`

Erzeugt aus einer Zahl eine Binärspeicherung in der so genannten Network Byte Order (auch: Big Endian Order). Verarbeitet werden dabei 16 Bit lange Ganzzahlen zwischen 0 und 65535. Wenn Sie mehrere Zahlen auf einmal verarbeiten wollen, geben Sie die Anzahl der Zahlen an. Anstelle einer Zahl ist auch `*` erlaubt. Benutzen Sie den Platzhalter, wenn Sie eine unbestimmte Anzahl Zahlen verarbeiten wollen.

`$IP_mit_Port = pack("Nn", 0xC19EAAC7,80);`

In dem Skalar `$IP_mit_Port` wird die IP-Adresse 193.158.170.199 und die Zahl 80, die für den Port des Webservers stehen soll, gespeichert. Die IP-Adresse wird dabei als 32 Bit lange Zahl in Hexadezimalschreibweise mit `N` verarbeitet, die Zahl für den Port, die kleiner ist, mit `n`.

`N[n]`

Erzeugt aus einer Zahl eine Binärspeicherung in der so genannten Network Byte Order (auch: Big Endian Order). Verarbeitet werden dabei 32 Bit lange Ganzzahlen zwischen 0 und 4294967295. Ansonsten wie `n`.

`$IP = pack("N", 0xC19EAAC7);`

In dem Skalar `$IP` wird die IP-Adresse 193.158.170.199 gespeichert. Die IP-Adresse wird dabei als 32 Bit lange Zahl in Hexadezimalschreibweise mit `N` verarbeitet. (Dezimal=Hexadezimal: 193=C1, 158=9E, 170=AA, 199=C7).

`v[n]` | Erzeugt aus einer Zahl eine Binärspeicherung in der so genannten VAX Byte Order (auch: Little Endian Order). Verarbeitet werden dabei 16 Bit lange Ganzzahlen zwischen 0 und 65535. Ansonsten wie `n`. | `$Wert = pack("v", 0xFFFF);` | In dem Skalar `$Wert` wird der höchstmögliche Wert gespeichert, den `v` verarbeitet, in Hexadezimalschreibweise als `FFFF` ausgedrückt.
`V[n]` | Erzeugt aus einer Zahl eine Binärspeicherung in der so genannten VAX Byte Order (auch: Little Endian Order). Verarbeitet werden dabei 32 Bit lange Ganzzahlen zwischen 0 und 4294967295. Ansonsten wie `n`. | `$Wert = pack("V", 0xFFFFFFFF);` | In dem Skalar `$Wert` wird der höchstmögliche Wert gespeichert, den `v` verarbeitet, in Hexadezimalschreibweise als `FFFFFFFF` ausgedrückt.
`f[n]` | Erzeugt eine binär gespeicherte Fließkommazahl. Die genaue Art der Speicherung ist vom Computertyp abhängig. Das kleine f steht für float, und zwar mit single precision, also einfacher Genauigkeit. Ansonsten wie `n`. | `$Wert = pack("f",(1/7));` | In einem Skalar `$Wert` wird das Ergebnis der Division von 1 durch 7 binär als Fließkommazahl gespeichert.
`d[n]` | Erzeugt eine binär gespeicherte Fließkommazahl. Die genaue Art der Speicherung ist vom Computertyp abhängig. Das kleine d steht für double float, also mit double precision, doppelter Genauigkeit. Ansonsten wie `n`. | `$Wert = pack("d",(1/7));` | In einem Skalar `$Wert` wird das Ergebnis der Division von 1 durch 7 binär als doppelt genaue Fließkommazahl gespeichert.

`p[n]`

Speichert die Arbeitsspeicheradresse einer nullterminierten Zeichenkette, wie sie in C üblich ist. Wenn Sie mehrere Zeichenketten auf einmal verarbeiten wollen, geben Sie die Anzahl der Zeichenketten an. Anstelle einer Zeichenkette ist auch `*` erlaubt. Benutzen Sie den Platzhalter, wenn Sie eine unbestimmte Anzahl Zeichenketten verarbeiten wollen.

`@Namen = ("Hans", "Peter", "Stefan");
$Anzahl = @Namen;
$Werte = pack("p" x $Anzahl, @Namen );
irgendeineFunktion($Anzahl, $Werte);`

In einem Skalar `$Anzahl` wird die Anzahl der Elemente von `@Namen` gespeichert. Dann wird die Liste `@Namen` zu einem einzelnen String von Adressen gepackt und in `$Werte` gespeichert.`$Anzahl` und `$Werte` werden dann einer Funktion übergeben.

`P[n]` | Speichert die Arbeitsspeicheradresse einer Struktur (struct) mit fester Bytelänge. Ansonsten wie `p`. | `use C::DynaLib::Struct; Define C::DynaLib::Struct('Adresse', 'pppi' => [qw(name ort strasse nummer)]); $Ausgabe = pack( 'P', $struct );` | Zunächst wird eine Struktur erstellt, wie sie C beispielsweise versteht. In dem Skalar `$Ausgabe` wird dann die Adresse der Struktur gespeichert.
`u[n]` | Erzeugt aus binären Daten eine UU-kodierte Zeichenkette. UU-Encode ist eines der Verfahren zum Umwandeln von 8-Bit-Daten (Bytes) in ein 7-Bit-Schema. Attachments von E-Mails wurden früher beispielsweise UU-kodiert übertragen. | `$UUDaten = pack("u", 1234);` | Die Zahl `1234`, ein binärer Wert auf 8-Bit-Basis, wird durch das UU-basierte Kodieren in Zeichen auf 7-bit-Basis umgewandelt.
`x[n]` | Erzeugt ein Byte mit dem Wert 0, ohne dafür ein Argument aus der Übergabeliste zu "verbrauchen". | `$Kette = pack("A* x A* x","Test","beispiel");` | Erzeugt aus den beiden Zeichenketten `Test` und `beispiel` eine Zeichenkette, die beide Teilstrings jeweils nullterminiert enthält.
`X[n]` | Geht `n` Byte im Ergebisstring zurück und löscht diese. | `$Stefan = pack("A* X2", "Stefanie");` | Die Anweisung erzeugt zunächst mit `A*` das Ergebnis "Stefanie" und entfernt dann die letzten beiden Bytes. Das Endergebnis ist dann "Stefan".

`@[n]`

Bringt den vorläufigen Ergebnisstring auf eine Länge von genau `n` Bytes. Ist der String zu lang, wird er einfach abgeschnitten, ist er zur kurz, wird er mit Null-Bytes aufgefüllt. Danach wird der Formatstring ganz normal weiterbearbeitet.

`$Walkman = pack("A* @3 A*","Walross","kman");`

Die Anweisung erzeugt zunächst mit `A*` das vorläufige Ergebnis "Walross", welches dann mit `@3` auf drei Zeichen, also "Wal" gekürzt wird. Anschließend wird noch "kman" angehängt. Das Endergebnis ist "Walkman".

## pos - Position der Anwendung von m/[regexp]/g auf Zeichenkette ermitteln

Reguläre Ausdrücke vom Typ `m/[regexp]/g` oder einfach `/[regexp]/g` können Zeichenketten nach allen Stellen durchsuchen, auf die der angegebene Ausdruck passt. Die Funktion `pos` liefert diejenige Position innerhalb der zu durchsuchenden Zeichenkette zurück, bei der die Suche beim jeweils nächsten Aufruf des regulären Ausdrucks fortfahren würde. Durch geschickte Verarbeitung innerhalb einer Schleife können mit Hilfe dieser Funktion alle Positionen innerhalb der gesamten Zeichenkette gefunden werden. Sie können diesen Wert auch ändern, um die Suche zu beeinflussen.

Erwartet als Parameter:
1. die zu durchsuchende Zeichenkette bzw. den Skalar, in dem diese gespeichert ist.

Gibt die nächste gefundene Position zurück, bei der die Suche fortfährt. Die Zeichen davor passen auf das Suchmuster.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    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 $Satz = "es ist was es ist";
    my $Suchwort = "ist";
    while($Satz =~ /$Suchwort/g) {
      my $Treffer = pos($Satz) - 3;
      print "Suchwort <b>$Suchwort</b> gefunden bei Position $Treffer<br>\n";
    }
    print "</body></html>\n";

### Erläuterung:

Das Beispiel-Script zeigt, wie Sie innerhalb einer Zeichenkette alle Vorkommnisse eines bestimmten gesuchten Musters auffinden und sammeln können. In dem Beispiel wird eine zu durchsuchende Zeichenkette `$Satz` definiert und mit einem Wert vorbelegt. Das Muster, nach dem innerhalb dieses Satzes gesucht werden soll, wird im Skalar `$Suchwort` definiert. In einer while-Schleife wird der Satz nach dem Suchwort durchsucht. Wichtig ist dabei hinter dem regulären Ausdruck die Option `g` für "global". Das Beispiel sendet HTML-Code an den Browser. Innerhalb der Schleife wird die Position jedes Vorkommens des gesuchten Musters ausgegeben. Dabei wird die Funktion `pos` auf die zu durchsuchende Zeichenkette `$Satz` angewendet. Der Rückgabewert ist die erste Position hinter dem gefundenen Suchmuster. Da das Beispiel nach einem bestimmten Wort "ist" sucht, das 3 Buchstaben hat, wird durch Subtrahieren von 3 die Anfangsposition ermittelt, an der das gesuchte Wort beginnt. Das Ergebnis wird jeweils in dem Skalar `$Treffer` gespeichert. Im Beispiel werden insgesamt zwei Zeilen ausgegeben, nämlich Gefunden-Hinweise für die Positionen 3 und 14. Der Grund: das Wort kommt zwei mal vor in dem Satz, und die Suche landet zweimal auf den Positionen dahinter, also bei den Positionen 6 und 17.

## reverse - Zeichenkette von hinten nach vorn umwandeln

Dreht eine Zeichenkette Zeichen für Zeichen um. Statt einer Zeichenkette können Sie auch eine Liste übergeben, deren Elemente vor der Umwandlung zu einer Zeichenkette verknüpft werden.

Erwartet als Parameter:
1. die Zeichenkette oder Liste, die bearbeitet werden soll.

Gibt eine bearbeitete Zeichenkette zurück.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my $Palindrom = reverse("EIN NEGER MIT GAZELLE ZAGT IM REGEN NIE");

    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 "$Palindrom\n";
    print "</body></html>\n";

### Erläuterung:

In dem Beispiel wird der klassische Satz "EIN NEGER MIT GAZELLE ZAGT IM REGEN NIE", den man rückwärts genauso lesen kann wie vorwärts (Palindrom-Effekt), zur Verdeutlichung verwendet. Die Funktion `reverse` wird auf diesen Satz angewendet, und der Rückgabewert wird in dem Skalar `$Palindrom` gespeichert. Zur Kontrolle wird HTML-Code ausgegeben.

Hinweis: Manche Leute regen sich ja über jeden Ausdruck auf, der nicht der gegenwärtigen "political correctness" entspricht. Aber mit einem Wort wie "Dunkelhäutiger" würde das Palindrom nun mal nicht funktionieren. Sie dürfen dieses Wort jedoch gerne probieren, wenn Ihnen nicht klar geworden sein sollte, dass `reverse` tatsächlich das tut, was soeben beschrieben wurde.

## split - Zeichenkette in mehrere Zeichenketten aufsplitten

Erzeugt aus einer Zeichenkette eine Liste von Teilzeichenketten, und zwar aufgrund eines regulären Ausdrucks, der das Trennsymbol definiert, das die einzelnen Teile trennt. Trennsymbole können eine beliebige Länge besitzen und müssen nicht bei jeder Fundstelle identisch sein.

Erwartet als Parameter:
1. einen regulären Ausdruck, der definiert, wie die Zeichenkette in einzelne Teile aufgespalten werden soll,
2. die Zeichenkette, die bearbeitet werden soll.

Gibt eine Liste mit den extrahierten Teilen der Zeichenkette zurück.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my $Satz = "Sage jeden Morgen guten Morgen zu dir selbst";
    my @Woerter = split(/ /,$Satz);
    my $Anzahl = @Woerter;

    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 "Der Satz <b>$Satz</b> hat $Anzahl Wörter\n";
    print "</body></html>\n";

### Erläuterung:

Das Beispiel definiert einen Satz. Auf den Satz wird die Funktion `split` angewendet. Dabei wird ein regulärer Ausdruck als erster Parameter übergeben, der nur auf Leerzeichen passt. Als zweiter Parameter wird der Skalar `$Satz` übergeben, in dem der Satz gespeichert ist. Die Funktion teilt den übergebenen Satz in Einzelelemente auf, die durch Leerzeichen voneinander getrennt sind - im Beispiel also in die einzelnen Wörter. Diese werden im Array `@Woerter` gespeichert. Im Beispiel soll zur Kontrolle nur die Anzahl der Wörter ermittelt werden, was durch die Anweisung `$Anzahl = @Woerter;` geschieht. Das Beispiel sendet danach HTML-Code an den Browser, der die ermittelte Anzahl der Wörter im Satz ausgibt.

## sprintf - Zeichenkette formatieren

Diese Funktion dient dazu, einzelne Datenelemente zu formatieren. So lassen sich Dezimalzahlen beispielsweise ohne viel Aufwand hexadezimal umrechnen, oder Gleitkommazahlen mit vielen Nachkommastellen auf eine bestimmte Anzahl Nachkommastellen trimmen.
Die `sprintf`-Funktion in Perl entspricht im wesentlichen der `sprintf`-Funktion in C.

Erwartet als Parameter:
1. Formatstring = eine Zeichenkette, die für bestimmte auszugebende Elemente Formatbezeichner enthalten kann. Die Syntax ist identisch mit der der printf-Funktion.
2. Ausgabeliste = ein oder mehrere Elemente, auf die sich die speziellen Formatbezeichner im Formatstring beziehen.

Gibt die formatierte Zeichenkette zurück.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my $BruttoBetrag = 27.95;
    my $NettoBetrag = $BruttoBetrag / 1.16;
    my $Formatiert = sprintf("Das im Bruttobetrag %s enthaltene Netto beträgt ungerundet %.2f", $BruttoBetrag, $NettoBetrag);

    print "Content-type: text/html\n\n";
    print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
    print "<html><head><title>Testausgabe</title></head><body>\n";
    print $Formatiert;
    print "</body></html>\n";

### Erläuterung:

Das Beispiel formatiert Hilfe der `sprintf`-Funktion die beiden Variablen `$BruttoBetrag` und `$NettoBetrag` in der Zeichenkette `$Formatiert`. Der Wert von `$NettoBetrag` wird rechnerisch gewonnen und stellt eine Bruchzahl mit vielen Nachkommastellen dar. In der mit Hilfe von `sprintf` formatierten Zeichenkette wird diese Zahl jedoch auf zwei Nachkommastellen reduziert.

Eine Auflistung der möglichen Formatbezeichner für diese Funktion finden Sie bei der Beschreibung der printf-Funktion.

## substr - Teilzeichenkette aus Zeichenkette extrahieren

Ermittelt aus einer Zeichenkette eine Teilzeichenkette an einer bestimmten Position und ersetzt sie gegebenenfalls durch eine andere.

Erwartet als Parameter:
1. die Zeichenkette, aus der extrahiert werden soll,
2. die Zeichenposition des ersten Zeichens der gewünschten Teilzeichenkette (erste Zeichenposition in einer Zeichenkette ist 0, zweite 1 usw.),
3. (optional) die Anzahl Zeichen, wie lang die gewünschte Teilzeichenkette sein soll,
4. (optional) eine Ersetzungszeichenkette

Gibt die bearbeitete Zeichenkette zurück.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my $Satz = "nutze den Tag!";
    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 $i lautet: $Zeichen[$i]<br>\n";
    }
    print "</body></html>\n";

### Erläuterung:

In dem Beispiel wird die Funktion `substr` verwendet, um die einzelnen Zeichen einer Zeichenkette in einer Liste zu speichern. Denn in Perl fehlt die für C typische Behandlung von Zeichenketten als Zeichen-Array. Anders als in C, das Zeichenketten nur als Array speichert, sind einzelne Zeichen einer Zeichenkette in Perl nicht direkt ansprechbar. Das Beispiel zeigt eine - wenn auch etwas umständliche - Methode, durch die einzelnen Zeichen der Zeichenkette zu iterieren (also die Zeichenkette Zeichen für Zeichen abzuarbeiten).
In dem Beispiel wird ein Skalar `$Satz` mit einem Wert definiert. Die Länge des Satzes wird in dem Skalar `$Satzlaenge` gespeichert (durch Anwendung von length). Anschließend wird der Satz Zeichen für Zeichen in einer for-Schleife in die Liste `@Zeichen` eingelesen. Dazu wird die Funktion `substr` so angewendet, dass sie jeweils ein Zeichen aus dem Satz "extrahiert". Zur Kontrolle gibt das Script HTML-Code aus, in dem die einzelnen Zeichen des Satzes untereinander aufgelistet werden.

## uc - alle Zeichen einer Zeichenkette in Großbuchstaben umwandeln

Wandelt Kleinbuchstaben in Großbuchstaben um und lässt Großbuchstaben und alle anderen Zeichen unberührt. Die entsprechende Gegenfunktion für Kleinbuchstaben ist lc.

Erwartet als Parameter:
1. die Zeichenkette, die bearbeitet werden soll.

Gibt die bearbeitete Zeichenkette zurück.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my $Satz = "mir ist nach Schreien zumute!";
    $Satz = uc($Satz);

    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 "$Satz\n";
    print "</body></html>\n";

### Erläuterung:

Das Beispiel definiert einen Satz in normaler Schreibweise. Aber jeder Internet-Freak weiß, dass man Großbuchstaben nur dann benutzen sollte, wenn einem nach Schreien zumute ist. Deshalb wird die Funktion `uc` auf den Satz angewendet und speichert ihren Rückgabewert in dem gleichen Skalar, der ihr als Parameter übergeben wird. Zur Kontrolle wird HTML-Code mit dem bearbeiteten Satz ausgegeben.

## ucfirst - erstes Zeichen einer Zeichenkette in Großbuchstabe umwandeln

Wandelt das erste Zeichen einer Zeichenkette in Großbuchstaben um, sofern es ein entsprechender Kleinbuchstabe ist. Die entsprechende Gegenfunktion für Kleinbuchstaben ist lcfirst.

Erwartet als Parameter:
1. die Zeichenkette, die bearbeitet werden soll.

Gibt die bearbeitete Zeichenkette zurück.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    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 $Wort = "fallen";
    print ucfirst($Wort);
    print "</body></html>\n";

### Erläuterung:

Das Beispiel gibt nur ein Wort aus. Bevor das Wort ausgegeben wird, wird allerdings die Funktion `ucfirst` darauf angewendet. Der führende Kleinbuchstabe wird dabei in einen Großbuchstaben verwandelt und ändert dadurch die Bedeutung des Wortes.

## unpack - Binärdaten auflösen

Macht (fast) alles rückgängig, was mit Hilfe der Funktion pack zu Binärdaten verwandelt wurde, oder anderweitig erzeugte Daten, die in eines der entsprechenden Binärformate passen.

Erwartet als Parameter:
1. die Formatierungsangabe, siehe Tabelle,
2. den Daten-Input.

Gibt die entsprechende Werteliste zurück.

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

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

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

    my $Satz = "Beam me up, Scotty";
    my @Zeichen = unpack("C*", $Satz);
    my $Quersumme = 0;
    foreach(@Zeichen) {
       $Quersumme += int($_);
    }

    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 "Die Zeichenwert-Quersumme des Satzes <b>$Satz</b> lautet <b>$Quersumme</b>\n";
    print "</body></html>\n";

### Erläuterung:

Die Formatierangabe `C` erzeugt bei der Funktion `pack` aus numerischen Angaben entsprechende Zeichenwerte. Bei `unpack` ist es umgekehrt. Da erzeugt die Funktion aus der Bytefolge, die der Zeichenkette der bei der Eingabe verwendeten Zeichenkodierung entspricht, eine Liste der numerischen Werte. Im Beispiel wird dies genutzt, um die Quersumme aller Zeichenwerte des Satzes zu ermitteln. Das Beispiel sendet HTML-Code an den Browser und gibt dabei das Ergebnis aus.
Alles weitere zu den komplexen Möglichkeiten dieser Funktion siehe pack.

| Funktionen für Listen bzw. Arrays und Hashes
| CGI-typische Aufgaben in Perl

© 2007 Impressum