# Zeichenketten

- Operatoren
- Vergleiche
- Funktionen

## Operatoren

Zeichenketten lassen sich mit Hilfe des Operators "`.`" verknüpfen und mit "`x`" vervielfachen.

Beispiel :

`#!/usr/local/bin/perl -w use strict; my $x = "A"; my $y = "."; my $c = $x.$y; print "$c\n"; $c = $c x 2; print "$c\n"; $c .= "*"; print "$c\n"; $c = $c x 3; print "$c\n";`

`A. A.A. A.A.* A.A.*A.A.*A.A.*`

[Seitenanfang]

## Vergleiche

Hier sind "größer" bzw. "kleiner" im Sinne einer Ordnung gemäß einer Zeichentabelle (ASCII, Unicode) zu verstehen und nicht etwa als Längenvergleich.

- "`eq`" liefert wahr bei Gleichheit
- "`ne`" liefert wahr bei Ungleichheit
- "`gt`" liefert wahr, falls linkes Argument größer als rechtes Argument
- "`lt`" liefert wahr, falls linkes Argument kleiner als rechtes Argument
- "`ge`" liefert wahr, falls linkes Argument größer oder gleich rechtem Argument
- "`le`" liefert wahr, falls linkes Argument kleiner oder gleich rechtem Argument
- "`cmp`" liefert -1, 0 oder 1 je nachdem, ob das linke Argument kleiner, gleich oder größer als das rechte Argument ist

Achtung: Diese Vergleiche gelten nur im String-Kontext, d.h., wenn zwei Zeichenketten verglichen werden. Zum Vergleich von Zahlen sehen die Operatoren anders aus.

[Seitenanfang]

## Funktionen

- `substr()`

  Mit Hilfe von `substr()` lassen sich Teilstrings aus Zeichenketten extrahieren. Die Argumente sind der zu untersuchende String, die Startposition (beginnend bei 0) sowie die Länge des gewünschten Teilstrings. Läßt man das letzte Argument weg, so erstreckt sich der Teilstrings bis zum Ende der vorgegebenen Zeichenkette.

  `#!/usr/local/bin/perl -w use strict; my $t = 'Kalender'; print substr($t,1,4)."\n"; print substr($t,5)."\n";`

  `alen der`

- `lc()` und `uc()`

  Diese Funktionen ersetzen alle Buchstaben in einem String durch die zugehörigen Klein- (`lc`, lower case) bzw. Großbuchstaben (`uc`, upper case).

  `#!/usr/local/bin/perl -w use strict; my $t = 'Perl'; print lc($t)."\n"; print uc($t)."\n";`

  `perl PERL`

- `lcfirst()` und `ucfirst()`

  Im Gegensatz zu `lc` verwandelt `lcfirst` nur den ersten Buchstaben in einen Kleinbuchstaben (sofern er nicht bereits klein geschrieben ist). Analog setzt `ucfirst` nur den ersten Buchstaben in Großschrift.

  `#!/usr/local/bin/perl -w use strict; my $t = 'PERL'; print lcfirst($t)."\n"; $t = 'perl'; print ucfirst($t)."\n";`

  `pERL Perl`

- `chop()`

  Hiermit wird das letzte Zeichen vom übergebenen String entfernt und als Funktionswert zurückgegeben.

  `#!/usr/local/bin/perl -w use strict; my $t = 'Perl'; chop($t); print $t;`

  `Per`

  Oft wird `chop()` dazu verwendet, den Zeilenvorschub am Ende einer Zeile abzuschneiden; hierfür eignet sich jedoch `chomp()` besser.

- `chomp()`

  Standardmäßig entfernt `chomp()` einen Zeilenvorschub ("`\n`") vom Ende eines Strings, sofern ein solcher vorhanden ist, und gibt die Anzahl der abgeschnittenen Zeichen zurück. `chomp()` sollte insbesondere dann gegenüber `chop()` bevorzugt werden, wenn nicht ganz sicher ist, ob die Zeichenkette am Ende einen Zeilenvorschub besitzt oder nicht.

  Genaugenommen entfernt `chomp()` am Ende eines Strings die Zeichenkette, die in der Variablen "`$/`" steht (Standardwert: "`\n`"). Ist "`$/`" leer, so werden alle Zeilenvorschübe abgeschnitten.

  `#!/usr/local/bin/perl -w use strict; my $string = "Hallo\n"; chomp($string); # Abschneiden von \n $string = "Hallo"; chomp($string); # keine Änderung von $string $/ = 'lo'; $string = "Hallo"; chomp($string); # $string ist nun "Hal" $/ = ''; $string = "Hallo\n\n\n"; chomp($string); # Entfernen aller \n`

- `length()`

  Hiermit wird die Länge einer Zeichenkette ermittelt (einschließlich aller Sonderzeichen).

  `#!/usr/local/bin/perl -w use strict; my $zeile = "Anzahl\tPreis\n"; print length($zeile)."\n";`

  `13`

- `join()`

  Das erste Argument ist hierbei eine Zeichenkette, die zwischen die nachfolgenden Strings beim Aneinanderhängen gesetzt wird.

  `#!/usr/local/bin/perl -w use strict; my $zeile = join('-','a','b','c','d'); print $zeile."\n";`

  `a-b-c-d`

- `split()`

  Hiermit kann eine Zeichenkette an bestimmten Stellen aufgetrennt werden. Die jeweilige Trennstelle gibt ein Suchmuster im ersten Argument an (siehe Reguläre Ausdrücke).

  `#!/usr/local/bin/perl -w use strict; my $zeile = "a-b-c-d"; my @a = split(/-/,$zeile); # Anzahl der Elemente print "@a\n";`

  `a b c d`

  Um die Anzahl der Teilstrings zu begrenzen, kann als drittes Argument noch eine Zahl angegeben werden, die die maximale Anzahl der gebildeten Stücke darstellt.

  `#!/usr/local/bin/perl -w use strict; my $zeile = "a-b-c-d"; my @a = split(/-/,$zeile,2); print "@a\n";`

  `a b-c-d`

  In diesem Beispiel enthält `@a` am Ende nur die beiden Elemente "`a`" und "`b-c-d`".

- `chr()`

  Mit `chr()` kann man Zeichen über ihre Position im verwendeten Zeichensatz darstellen. Im folgenden Beispiel wird der Anfang des Alphabets im ASCII-Zeichensatz ausgegeben:

  `#!/usr/local/bin/perl -w print chr(65).chr(66).chr(67)."\n";`

- `ord()`

  Die Umkehrung der obigen Funktion `chr()` ist `ord()`: Sie gibt die Position des ersten übergebenen Zeichens in der Zeichensatztabelle aus. Das nächste Beispiel zeigt die ASCII-Codes der ersten Buchstaben des Alphabets:

  `#!/usr/local/bin/perl -w print ord('A').' '.ord('B').' '.ord('C')."\n";`

[Seitenanfang]

Autor: Eike Grote | Version: 2.05 (24.1.2012)