Farid Hajji: Perl: Einführung, Anwendungen, Referenz (2/e) [Kapitel 5: Strings]

Farid Hajji

Perl: Einführung, Anwendungen, Referenz (2/e) [Support-Site]

Farid Hajji: Perl - Einführung, Anwendungen, Referenz
2., aktualisierte und erweiterte Auflage
Addison-Wesley Longman, ISBN 3-8273-1535-2

Kapitel 5: Strings

Inhalt

Synopsis
Eigenschaften von Strings
Quoting
Zeichenliterale
Operationen mit Strings
- Vergleichsoperatoren
- Manipulation von Teilstrings mittels substr()
- Konkatenation von Strings
- Wiederholung eines Strings
- Der magische Stringinkrementationsoperator ++
- Länge eines Strings
- Umkehrung eines Strings
- Zerlegung mittels unpack()
- Zusammensetzung mittels pack()
- ASCII-Darstellung
  - chr() und ord()
  - sprintf()
  - pack() und unpack()
- Entfernen des letzten Zeichens mittels chomp()
- Groß- und Kleinschreibung
Reguläre Ausdrücke
- Motivation
- Suchen in Strings
- Transliteration mit tr/// bzw. y///
- Der Substitutionsoperator s///
- Aufbau von regulären Ausdrücken
  - Atome
  - Zero-Width-Assertions
  - Quantifier
  - Auswertung von links nach rechts
  - Gierig oder bescheiden?
  - Anker
  - Klammern und Speicherung
  - Syntax runder Klammern
Exkurs: lex und yacc für Perl
- Selbstgebastelter Lexer mit eval()
- Modul Parse::Lex
- Yacc mit Perl-Ausgabe: byacc -p
Internationale Belange
Aufgaben

Synopsis

"Hello, $interpolated string!"    # Doppelt gequoteter String
'I see $$ in your eyes!'          # Keine Interpolation
`ps -ax`                          # Unix-Kommandos in Backticks
$var = <<ENDE;                    # HERE-Dokument
...
ENDE

"\a,\b,\e,\f,\n,\r,\t,\\,\033,\x1b,\cJ"  # C-Sonderzeichen

$str1 {eq,ne,lt,le,gt,ge,cmp} $str2      # Vergleichsoperatoren

$teil = substr($quelle, $offset, $laenge);
substr($ziel, $offset, $laenge) = $neuer_teilstring;

$beides = $teil1 . $teil2;        # Konkatenation
$zeile  = "-" x 80;               # Wiederholung

$var = "Haaa"; ++$var;            # Neuer Wert: "Haab"

$laenge = length($string);        # Anzahl der Zeichen
$gnirts = reverse($string);       # String, andersrum

@liste  = unpack("A1 A5 x3 A*", $eingabe);
$string = pack("A1 A5 A*", @liste);

$ascii  = ord($char);             # Zeichen -> ASCII
$char   = chr($ascii);            # ASCII   -> Zeichen

$var =~ tr/A-Z/a-z/;              # 7-Bit-Konvertierung
uc(), lc(), ucfirst(), lcfirst(); # Gross- und Kleinschreibung
"\U, \L, \u, \l, \E"              # Umschaltzeichen

use locale;                       # 8-Bit-Code mit Umlauten...
no locale;                        # Nur 7-Bit-ASCII

print "found!" if $var =~ /Regexp/gismox;
$var =~ s/Regexp/newvalue/egismox;
$count = $var =~ tr/Vonliste/Nachliste/;

Beispielprogramme

`herequotes.pl`	HERE-Dokumente und Interpolation
`stringparts1.pl`	Zerlege einen String an bestimmen Positionen
`stringparts2.pl`	`unpack()` und automatische Template-Erzeugung
`stringparts3.pl`	Die `"... a*"`-Form bei `unpack()`-Templates
`stringparts4.pl`	Zerlege den String in Chunks konstanter Länge
`string2chars.pl`	Zerlege Strings in einzelne Zeichen mit `unpack()`
`stringpack1.pl`	Erzeugt ein String fester Feldlängen mit `pack()`
`uuencode.pl`	Implementation von `uuencode`(1) in Perl mit `pack()`
`string2ascii.pl`	Zerlege Strings in einzelne Zeichen mit `unpack()`
`ascii2string.pl`	Konvertiert eine Liste von ASCII-Codes -> String
`soundex.pl`	"weicher" Vergleich von Namen
`regexp-o.pl`	Zeigt den Vorteil von `m//o` gegenüber `m//`
`regexp-g-scalar.pl`	`m//g` im skalaren Kontext
`regexp-g-list.pl`	`m//g` im Listenkontext
`regexp-quantors.pl`	Verwendung von Quantifiern in Regexps
`wc.lex`	Eine Lex-Spezifikation zum Zählen von Wörtern
`mini-lexer.pl`	Simuliert eine Teilmenge des `lex`(1)
`mywc.pl`	`wc.lex` simuliert mit `Parse::Lex`
`calc.y`	Yacc-Spezifikation eines einfachen Taschenrechners
`calc.pl`	Taschenrechner mit der Perl-Version von `lex` und `yacc`
`calc-with-eval.pl`	Taschenrechner mit `eval()`-Unterstützung
`upcase8bit.pl`	Konvertiert 8-Bit-Strings in Großschreibung
`string8bitsort.pl`	Sortierung von Strings mit Umlauten.

Ergänzungen

Zu Seite 66, Mitte: Der zweite print()-Ausdruck mit dem HERE-Dokument ist nicht mit einem Semikolon abgeschlossen worden. Das ist nur dann richtig, wenn es sich hierbei um den letzten Befehl eines Blocks handelt (Sie erinnern sich: In Perl werden einzelne Ausdrücke mit einem Semikolon voneinander getrennt, wie in Pascal. Bei C muß hingegen jeder Ausdruck mit einem Semikolon abgeschlossen werden). Um das Beispiel leicht zu ergänzen:
```
print length(<<TOKEN) + 5,
" blah\n";
1234567890
TOKEN
;
# Hier naechster Befehl.
```
Beachten Sie bitte, daß das auf " blah\n" folgende Semikolon zum HERE-Dokument gehört, und nicht etwa den print()-Befehl vom Rest trennt. Das zweite Semikolon hingegen gehört nicht mehr zum HERE-Dokument und trennt folglich print() von nachfolgenden Befehlen. (1999/11/27, nach einem Hinweis von Joachim Backes)
Zu regexp-o.pl, Seite 87: Der Ausdruck
```
$tstart = [gettimeofday];
```
bedeutet folgendes: Zunächst wird die Funktion gettimeofday() des Moduls Time::HiRes aufgerufen. Die runden Klammern können weggelassen werden, da sie zur Eindeutigkeit nicht notwendig sind. Die Funktion gettimeofday() liefert im hier vorliegenden Listenkontext eine Liste von Ergebnissen zurück (was das bedeutet erfahren Sie in Kapitel 10). Die eckigen Klammern erzeugen nun eine Kopie dieser Liste und liefern eine Referenz (d.h. ein Zeiger), die darauf zeigt, zurück. Dies wird in Kapitel 13 ausführlich erklärt. Dieser Zeiger kann als Zeitstempel aufgefaßt werden, der von der Funktion tv_interval() von Time::HiRes benötigt wird. Diese Notation wurde an dieser Stelle noch nicht erläutert, da sie für das dort behandelte Thema nicht wirklich relevant ist.
Zur Seite 92, ganz unten: Daß die Suche erst wieder nach der letzten Suchposition aufgenommen wird, wird doch allein schon durch /g bzw. /gc sichergestellt. Auch ohne \G würden vorherige Tokens nicht gefunden werden. Durch \G wird jedoch der reguläre Ausdruck an der Position verankert, an dem die Suche beim nächsten /foo/gc fortgesetzt werden würde. Die auf \G folgende Zeichenkette muß also an der nächsten Suchposition beginnend plaziert sein um einen Match zu liefern. (Thomas Steinke, 2000/02/01)
Zu Abschnitt 5.6.3, Seiten 93pp: Als Parameter des tr///- bzw. y///-Operators ist der Begriff Liste gefallen. Gemeint ist hier eine Liste von Zeichen, also eine Zeichenfolge. Es handelt sich hierbei nicht um eine Perl-Liste!

Lösungen zu ausgewählten Übungsaufgaben

Aufgabe 3, Seite 124: Verschachtelte Verwendung des Wiederholungsoperators x:
```
farid@sun-1:~> perl -e 'print scalar (". " x 19 . "\n") x 19'
. . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . 
[... etc. insgesamt 19 mal ...]
```
Die Funktion scalar() ist hier erforderlich, weil print() seine Argumente im Listenkontext auswertet, das innere x jedoch ein String ". " und nicht eine Liste 19-mal wiederholen soll. Daher wird mit scalar() ein skalarer Kontext für die innere "Schleife" erzwungen. Die äußere "Schleife" hingegen bedeutet nur, daß eine Liste mit 19 Strings erzeugt werden soll. Mit anderen Worten, bekommt print() insgesamt 19 Argumente! Das innere x ist ein Stringwiederholungsoperators, das äußere hingegen ein Listenwiederholungsoperator (siehe Kapitel 7).Das Problem ist auch ohne die Funktion scalar() wie folgt lösbar:
```
farid@sun-1:~> perl -e '$var = (". " x 19 . "\n") x 19; print $var'
. . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . 
[... etc. insgesamt 19 mal ...]
```
Bei der Zuweisung an $var wird der skalare Kontext grundsätzlich erzwungen. Somit handelt es sich bei beiden x um den Stringwiederholungsoperator.

FAQ

In Vorbereitung

Errata

Seite 61, 13. Zeile von unten: Ersetze $gnirst durch $gnirts.
Seite 84, 6. Zeile von unten. Es fehlte der abschließende Slash:
```
$path =~ m/\/usr\/local\/bin/    # LTS
```
Seite 91, 10. Zeile von unten: Ersetze:
```
/(cat)|(dog)|(rabbit)/
```
durch
```
/(dog)|(cat)|(rabbit)/
```
damit auch dog in $1, cat in $2 etc. landen.
Seite 107, 3. Zeile des Unterabschnitts Gierig oder bescheiden?: Sie versuchen also, gierig alle... statt Sie versuchen also, grierig alle...
Seite 114, 11. Zeile von unten: Der Aufruf heißt natürlich:
```
farid@sun-1:~/p> ./mini-lexer.pl wc.lex
```

Errata, 1. Nachdruck

Seite 78, 9. Zeile von oben. Ersetze im Programm uuencode.pl shift durch $ARGV[0].
Seite 89, 5. Zeile von unten: Ersetze:
```
if ($var =~ /<title>(.*)</title>/) {
```
durch
```
if ($var =~ /<title>(.*)<\/title>/) {
```
Denn der Slash muß natürlich hier entwertet werden.
Seite 90, 1. Zeile von oben: Ersetze:
```
if ($var =~ /<title>(.*)</title>/s) {
```
durch
```
if ($var =~ /<title>(.*)<\/title>/s) {
```
Auch hier muß der Slash entwertet werden.

[Prev] [Up] [Next]

[Alte Quelle]