SELFHTML/Navigationshilfen CGI/Perl Perl-Funktionen| SELFHTML/Navigationshilfen CGI/Perl Perl-Funktionen |
 |
Funktionen für Zeichenketten |
|
|
 | |
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 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.
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%" |
#!/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"; |
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.
|
|
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.
Weitere Erklärungen zum Unterschied zwischen chop und chomp, und ein vollständiges Beispiel mit Erläuterung finden Sie bei der Beschreibung zu chomp.
|
|
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.
#!/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";
|
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.
|
|
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.
#!/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";
|
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.
|
|
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.
#!/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";
|
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.
|
|
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.
#!/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";
|
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.
|
|
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.
#!/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"; |
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.
#!/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";
|
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.
|
|
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.
#!/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";
|
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.
|
|
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.
#!/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";
|
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.
#!/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";
|
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.
|
|
|
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.
#!/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";
|
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.
|
|
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.
#!/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";
|
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.
|
|
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.
#!/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"; |
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.
|
|
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
#!/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";
|
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.
|
|
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.
#!/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"; |
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.
|
|
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.
#!/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"; |
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.
#!/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";
|
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
|
| SELFHTML/Navigationshilfen CGI/Perl Perl-Funktionen |
© 2001 
selfhtml@teamone.de