Um die hier versammelten Funktionen zu verstehen, sollten Sie die allgemeinen Bemerkungen zu 
Zeichenketten in Perl kennen.
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-Rechnern finden kann. 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.
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.
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.
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, so dass die Zuordnung zwischen Zeichenwert und ASCII-Codetabelle deutlich wird.
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.
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ü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.
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.
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.
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.
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.
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.
Erwartet als Parameter:
1. die gewünschte Zeichenkette.
Gibt die Anzahl Zeichen in der Zeichenkette zurück.
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.
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.
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.
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.
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, 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 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.
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`.
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 42949672965 (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". |
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
© 2005 Impressum
SELFHTML/Navigationshilfen 
