| ## 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 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 die 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 autoexec.bat):

    mode con codepage prepare=((850) C:\WINDOWS\COMMAND\ega.cpi)
    mode con codepage select=850
    keyb gr,,C:\WINDOWS\COMMAND\keyboard.sys
    SET PATH=d:\PERL\BIN;"%PATH%"

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

    #!/usr/bin/perl -w

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

    open(AUTOEXEC, "<c:/autoexec.bat") || die "Fehler aufgetreten: $!";
    my @Zeilen = <AUTOEXEC>;
    close(AUTOEXEC);
    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 autoexac.bat, wie man sie auf DOS/Windows-Rechnern findet. Im CGI-Script des Beispiels wird die Datei in den Array `@Zeilen` eingelesen. Anschließend 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 an den Browser aus. Innerhalb eines `<pre>`-Bereichs, wo 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 Zeichenfolge.

## chop - letztes Zeichen entfernen

Entfernt das letzte Zeichen aus einer Zeichenkette. Im Gegensatz zu der Funktion chomp entfernt `chop` in jedem Fall das letzte Zeichen, egal um was 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.

### Beispiel mit Erläuterung:

Weitere Erklärungen zum Unterschied zwischen `chop` und `chomp`, und ein vollständiges Beispiel mit Erläuterung finden Sie bei der Beschreibung zu `chomp`.

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

    #!/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-Zeichensatzbelegung 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 Webseiten 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:

    #!/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 Beispielscript 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 angewendet, 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.

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

    #!/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 sendet HTML-Code an den aufrufenden Browser. 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:

    #!/usr/bin/perl -w

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

    opendir(DIR, "c:/windows");
    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.

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

    #!/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:

    #!/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.teamone.de/.

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:

    #!/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 an den Browser zurück.

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

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:

    #!/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:

Das Beispiel sendet folgende HTML-Ausgabe an den Browser:

    Anna      Lyse          07.07.1977wBau 21 Zi 280 seit 03/1999 Team-Assistenz Marketing
    Rainer    Zufall        29.02.1960mBau 113Zi 11  Bereichsleiter Entwicklung

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, so dass 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 mit `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:

    #!/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 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 null-terminiert, 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 (nach ASCII-Zeichensatz) 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 sogenannten 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 sogenannten 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 sogenannten 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 sogenannten 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-encodierte Zeichenkette. UU-Encode ist eines der Verfahren zum Umwandeln von 8-Bit-Daten (Bytes) in ein 7-Bit-Schema. Attachments von Mails wurden früher beispielsweise UU-codiert übertragen. | `$UUDaten = pack("u", 1234);` | Die Zahl `1234`, ein binärer Wert auf 8-Bit-Basis, wird durch das UU-basierte Encodieren 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:

    #!/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 Beispielscript 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:

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

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.

## split - Zeichenkette in mehrere Zeichenketten aufsplitten

Erzeugt aus einer Zeichenkette eine Liste von Teilzeichenketten, und zwar aufgrund eines reglurären Ausdrucks, der das Trennsymbol definiert, das die 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:

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

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

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

    #!/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` dazu 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 der Zeichenkette sind 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 sendet das Script HTML-Code an den Browser, 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 Großbuchstaben 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:

    #!/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 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 an den Browser gesendet, der den bearbeiteten Satz ausgibt.

## 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 Großbuchstaben 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:

    #!/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:

    #!/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 Zeichencodierung entspricht, eine Liste der numerischen Werte. Im Beispiel wird dies dazu 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

© 2001 selfhtml@teamone.de