Perl 1

Perl 2

Perl 3

Perl 4

Perl 5

Perl 6

Zurück

Stringoperationen und Kontrollstrukturen

Einführung in PERL II

von Achim Schmidt

In der ersten Folge dieser Artikelserie haben wir uns die Grundstruktur eines Perlprogrammes, das (grobe) Variablenhandling und mathematische Operationen in Perl angesehen. Im heutigen Teil geht es nun um Stringoperationen und damit zusammenhängende Themen wie Vergleiche und Schleifen.

Einfache Stringoperationen in PERL

PERL bietet eine Reihe von Möglichkeiten Zeichenketten zu manipulieren. Auf die wesentlichen werde ich nun eingehen, weitere werde ich im Laufe der Artikelserie bei Bedarf an Hand von Beispielen näher erläutern.

Als erstes wollen wir uns einmal Operatoren zum verknüpfen und vervielfachen von Variablen ansehen. PERL kennt dazu folgende Operatoren: 

	Operator		Bedeutung

	.			Verkettung
	x			Vervielfachung

Dabei ist zu beachten, daß dem Vervielfachungsoperator ein Wert folgen muss, welcher die Anzahl der Duplikate bezeichnet.

Beispiel: 

	$a = "Hallo" x 3;
Diese Zeile speichert in der Variablen $a den Text "HalloHalloHallo", eben den angegebenen Text mal 3!

Mit dem Verkettungsoperator "." lassen sich mehrere Strings verbinden. Hier werden die Einzelstrings, jeweils getrennt durch Punkte, hintereinander angegeben.

Beispiel: 

	$a = "Linux" . "Magazin";
Diese PERL-Zeile speichert den String "LinuxMagazin" in der Variablen $a.

Deutlicher sollten die Funktionen der Operatoren an folgendem Beispielprogramm (Siehe Abbildung 1, mit Ausgabe des Programmes) werden:

Abbildung 1: Stringverkettung und -vervielfachung 

#!/usr/bin/perl

# Beispielprogramm: demo2-1.pl

{
	$a = "Linux";
	$b = "Magazin";

	$c = $a . $b ;
	$d = $a x 3;
	$e = $a . " " . $b;
	$f = $e x 2;

	print "\nVariable 1: $a \nVariable 2: $b \n";
	print "Variable 3 = Variable 1 verkettet mit Variable 2: $c \n";
	print "Variable 4 = Variable 2 verdreifacht: $d \n";
	print "Variable 5 = Variable 1 mit Leerraum und Variable 2 verknuepft: $e\n";
	print "Variable 6 = Variable 5 verdoppelt: $f\n"; 
}


Variable 1: Linux 
Variable 2: Magazin 
Variable 3 = Variable 1 verkettet mit Variable 2: LinuxMagazin 
Variable 4 = Variable 2 verdreifacht: LinuxLinuxLinux 
Variable 5 = Variable 1 mit Leerraum und Variable 2 verknuepft: Linux Magazin
Variable 6 = Variable 5 verdoppelt: Linux MagazinLinux Magazin

Funktionen zur Stringmanipulation

Neben den erläuterten Stringoperationen kennt PERL eine Reihe von Funktionen zur Stringmanipulation. Im folgenden werde ich lediglich auf die wesentlichen Funktionen eingehen, weitere werde ich bei Bedarf im Verlauf der Artikelserie erläutern.

Eine Stringfunktion habe ich bereits im ersten Teil der Artikelserie verwendet, ohne näher auf sie einzugehen. Dies ist die Funktion chop(), welche das letzte Zeichen eines Strings entfernt. Ich habe die Funktion verwendet, um das bei Eingaben übergebene RETURN Zeichen aus dem Eingabestring zu entfernen. Grundsätzlich ist diese Funktion aber vielseitiger einsetzbar, da sie einfach das letze Zeichen einer Zeichenkette entfernt.

Die Syntax der Chopfunktion lautet: 

  chop(Variable);
Dabei wird das letzte Zeichen der in der Klammer bezeichneten Variable aus ihr entfernt.

Eine weitere Funktion ist die join () Funktion, welche es ermöglicht Strings zu verbinden, und dabei zwischen die einzelnen Zeichenketten ein Trennzeichen einfügt. Die Syntax der Funktion lautet: 

	 VariableX  = join ( Trennzeichen,Variable1,Variable2,..., VariableN );
Diese Funktion fügt in der Variablen VariableX alle bezeichneten Variablen zusammen, wobei zwischen die Einzelvariablen, der als Trennzeichen bezeichnete Text eingefügt wird.

Um nun Zeichenketten innerhalb eines Strings zu finden, kennt PERL die Funktion index(), welche die Position des ersten Vorkommens einer Zeichenkette innerhalb eines Strings angibt. Als Option kann Ihr auch ein Offset angegeben werden, ab welcher Position innerhalb des Strings die Suche begonnen werden soll. Daraus ergibt sich dann auch die Syntax der Funktion, welche wie folgt aussieht: 

$ergebnis = index (Quellstring,zu suchender Substring,[Offset])

Wird die angegebene Zeichenkette innerhalb des Strings nicht gefunden, so wird der Wert -1 zurückgegeben. Zu beachten ist, daß die Funktion bei Null anfängt zu zählen, d.h. ist der Rückgabewert der Funktion 5, so ist das 6te Zeichen das erste Zeichen des Suchstrings ! Desweiteren ist zu beachten, daß die Funktion casesensitive sucht, also zwischen Groß- und Kleinschreibung unterscheidet.

Abbildung 2: Auffinden von Zeichenketten innerhalb eines Strings 

#!/usr/bin/perl

# Beispielprogramm: demo2-3.pl

{
	print "\nGeben Sie einen String ein: ";
	$eingabe = <stdin>;
	chop ($eingabe);
	print "\nGeben Sie einen zu suchenden Teilstring ein: ";
	$suchwort = <stdin>;
	chop ($suchwort);

	$startpos = index ($eingabe,$suchwort);

	print "\nDas Teilstring $suchwort beginnt ab Zeichen $startpos !\n\n";	
}


Geben Sie einen String ein: Dies ist ein Beispieltext  

Geben Sie einen zu suchenden Teilstring ein: spiel

Das Teilstring spiel beginnt ab Zeichen 16 !

Eine weitere oft benötigte Funktion ist die Funktion length(), welche die Länge eines Strings ermittelt. Ihr wird als Argument einfach der entsprechende String übergeben. Ihre Syntax sieht also folgendermaßen aus: 

$laenge = length(<String>)

Die letzte Stringfunktion, welche ich hier erläutern moechte, dient dem Ausschneiden einer Zeichenkette aus einem String. Die Funktion, welche dies erlaubt, ist die Funktion substr(), welche als Argumente den Quellstring und die Startposition benötigt, und optional die Länge des auszuschneidenden Teilstrings akzeptiert.
Ihre Syntax lautet: 

$teilstring = substr(STRING,STARTPOS[,LAENGE])

Zu beachten ist ,daß auch diese Funktion bei Null mit dem Zählen beginnt, demzufolge also das dritte Zeichen die Position 2 hat !

Abbildung 3: Teilstring ausschneiden 

#!/usr/bin/perl

# Beispielprogramm: demo2-4.pl

{
	print "\nGeben Sie einen String ein: ";
	$eingabe = <stdin>;
	chop ($eingabe);

	print "\nGeben Sie die Position an, ab der ausgeschitten werden soll:";
	$start = <stdin>;
	chop ($start);

	print "\nGeben Sie die Anzahl der auszuschneidenden Zeichen ein: ";	
	$laenge = <stdin>;
	chop ($laenge);

	$teil = substr ($eingabe,$start,$laenge);

	print "\nTeilstring: $teil\n\n"
}


Geben Sie einen String ein: Wo soll den abgeschnitten werden?

Geben Sie die Position an, ab der ausgeschitten werden soll:
16

Geben Sie die Anzahl der auszuschneidenden Zeichen ein: 7

Teilstring: schnitt

Kontrollstrukturen

Unter Kontrollstrukturen fasst man im allgemeinen Schleifen und Befehle zur bedingten Verzweigung zusammen, da diese den Programmlauf kontrollieren. Ich werde als erstes auf eine der wichtigsten Kontrollstrukturen eingehen, nämlich die if Anweisung.

Die if Anweisung erlaubt die bedingte Verzweigung. Dies bedeutet, daß sie den Programmablauf in Abhängigkeit von Variableninhalten steuert. Somit ist es möglich auf unterschiedliche Variablenwerte (und somit Eingaben und Ergebnisse) zu reagieren und Abhängigkeiten aufzubauen.

Grunsätzlich teilt sich die if Anweisung in mehrere Befehlsblöcke auf. Schematisch sieht dieser so aus: 

	if (Abhaengikeit) 
 	 {
		Befehlsblock 1
	 }
	else
	 {
		Befehlsblock 2
	 }

Die Funktion ist dabei folgendermaßen: PERL überprüft das Abhänhigkeitskriterium hinter der if Anweisung. Liefert diese wahr zurück (d.h. die Abhängigkeit ist erfüllt), so wird der Befehlsblock 1 ausgeführt und der hinter else stehende Befehlsblock 2 ignoriert. Liefert das Abhängigkeitskriterium jedoch falsch als Ergebnis (Bedingung ist nicht erfüllt), so wird der hinter dem else stehende Befehlsblock 2 ausgeführt. Wichtig ist, daß die einzelnen Befehlsblöcke in geschweiften Klammern stehen und somit als zusammenhängender Block gekennzeichnet sind. Das else, und der folgende Befehlsblock sind übrigens optionsl, d.h. er ist nicht zwingend erforderlich. Existiert dieser Block nicht und die angegebene Bedingung liefert false, wird innerhalb des PERL Programmes einfach mit der nächsten Anweisung ausserhalb des Bedingungsblockes 1 fortgefahren.

Sehen wir und das ganze einmal anhand des folgenden Beispiels (siehe Abbildung 4) an:

Abbildung 4: Bedingte Verzweigung mittels if-else 

#!/usr/bin/perl

# Beispielprogramm: demo2-5.pl

{
	print "\nWie alt bist Du ? ";
	$eingabe = <stdin>;
	chop ($eingabe);

	if ($eingabe < 18)
	  {
		print "\n Du bist also noch nicht volljöhrig !\n\n";
	  }
	 else
	  {
		print "\n Du bist schon erwachsen\n\n";
	  }
}


% demo2-5.pl

Wie alt bist Du ? 34

 Du bist schon erwachsen

% demo2-5.pl

Wie alt bist Du ? 14

 Du bist also noch nicht volljaehrig !

Das Programm erzeugt nun in Abhängigkeit des eingegebenen Alters unterschiedliche Ausgaben, wobei das Kriterium innerhalb der if Zeile steht 

($eingabe < 18)
. Hier wird also überprueft, ob der eingegebene Wert kleiner als 18 ist. Ist dies der Fall wird der Anweisungsblock, welcher unmittelbar hinter der Bedingungsanweisung innerhalb der if Zeile steht ausgeführt und der Anweisungsblock hinter else ignoriert. Ist diese Bedingung falsch, wird eben dieser Anweisungsblock übersprungen und mit dem else Block weitergemacht.

Wie Sie eventuell bereits bemerkt haben, verleiht uns diese Kontrollmöglichkeit eine enrome Flexibilität um unseren Programmablauf zu gestalten. Die if Anweisung kann jedoch noch ein weiteres Stück flexibler sein, wenn man die elsif Möglichkeit hinzuzieht. elsif erlaubt eine verfeinerte Bedingungsprüfung, was an folgendem Beispiel (siehe Abbildung 5) klar werden dürfte:

Abbildung 5: Bedingte Verzweigung mittels if-elsif-else 

#!/usr/bin/perl

# Beispielprogramm: demo2-6.pl

{

	print "\nWie alt bist Du ? ";
	$eingabe = <stdin>;
	chop ($eingabe);

	if ($eingabe < 18)
	  {
		print "\n Du bist also noch nicht volljährig !\n\n";
	  }
	 elsif ($eingabe <  65)
	   {
		print "\n Du bist erwachsten, darfst aber noch nicht in Rente!\n\n";
	   }
	 else
	  {
		print "\n Hast Deine Rente vedient !\n\n";
	  }


}

Das Programm liefert folgende Ausgabe:

Obiges Beispiel ist das bereits aus dem Programm demo2-5.pl bekannte Listing in etwas abgewandelter Form. Neu ist hier die zusätzliche Verwendung des elsif Statements. Dieses Statement ermöglicht eine weitere Bedingungsabfrage, wird jedoch nur durchlaufen, wenn vorher noch keine Bedingung zutraf. Die else Anweisung wird nun nur noch durchlaufen, wenn weder die if Bedingung noch eine elsif Bedingung als Prüfwert wahr lieferte.

Eine weitere Möglichkeit in den Programmablauf einzugreifen sind Schleifen. Sie ermöglichen die mehrfache Ausführung eines Programmblockes. Eine Schleife teilt sich normalerweise in Schleifenkopf und in einen Anweisungsblock auf. Der Anweisungsblock wird durchlaufen, solange die Bedingung im Schleifenkopf erfüllt ist.

PERL kennt nun verschiedene Schleifen. Die erste Schleife, auf welche ich hier eingehen werde, ist die sogenannte while Schleife. Diese hat den Namen von ihrem einleitenden Befehl, nämlich while. Schematisch sieht diese Schleife so aus: 

	while (Bedingung)
 	  {
		Anweisungsblock
	  }
Der Anweisungsblock wird dabei solange ausgeführt, wie die im Schleifenkopf enthaltene Bedingung als Ergebnis wahr liefert.

Abbildung 6: while - Schleife 

#!/usr/bin/perl

# Beispielprogramm: demo2-7.pl

{

	print "\nProgramm zur Berechnung der Quadratzahlen\n";
	print "\nStartwert: ";
	$startwert = <stdin>;
	chop ($startwert);

	print "Endwert: ";
	$endwert = <stdin>;
	chop ($endwert);

	while ($startwert <= $endwert)
	 {
	
		print "\nQuadratzahl von $startwert ist ".$startwert * $startwert;
		$startwert ++ ;
	 }

	print "\n\n ** Programmende **\n\n\n";

}

Das Beispielprogramm berechnet die Quadratzahlen von allen Zahlen, welche zwischen dem eingegebenen Start- und Endwert liegen, wobei diese beiden Werte selbst eingeschlossen sind. Die Bedingung der while Schleife lautet:

Führe den folgenden Anweisungsblock solange aus, wie der Startwert kleiner oder gleich dem des Endwertes ist.

Der Startwert selbst wird dabei bei jedem Durchlauf des Schleigenkörpers (Anweisungsblock) mittels der Anweisung $startwert ++, um den Wert eins inkrementiert (erhöht). Sobald der Startwert dabei größer als der eingegebene Endwert liegt, liefert die Bedingungspruefung den Wert false und die Schleife wird nicht länger ausgeführt, stattdessen geht es mit der nächsten Anweisung nach dem Schleifenkörper weiter.

Ein entsprechender Programmlauf könnte also folgendermaßen aussehen:

Eine weitere Form der Schleife ist die until - Schleife. Sie arbeitet genau entgegengesetzt zur while Schleife, d.h. ihr Schleifenkörper wird solange ausgeführt, wie die Bedingung false liefert.

Abbildung 7: while - Schleife 

#!/usr/bin/perl

# Beispielprogramm: demo2-8.pl
{

	print "\nProgramm zur Berechnung der Quadratzahlen\n";
	print "\nStartwert: ";
	$startwert = <stdin>;
	chop ($startwert);

	print "Endwert: ";
	$endwert = <stdin>;
	chop ($endwert);

	until ($endwert < $startwert)
	 {
	
		print "\nQuadratzahl von $endwert ist ".$endwert * $endwert;
		$endwert -- ;
	 }

	print "\n\n ** Programmende **\n\n\n";

}

Dieses Beispiel erfüllt den gleichen Zweck wie das Beispiel zuvor, bedient sich nun jedoch der until Schleife und geht vom Endwert zurück bis zum Startwert. Der Schleifenkörper wird nun ausgeführt bis der Endwert kleiner als der Startwert ist !

Zum Abschluß der heutigen Folge möchte ich Ihnen noch eine Übersicht, über die verfügbaren Vergleichsmöglichkeiten und deren Operatoren geben (siehe Abbildung 8):

Abbildung 8: Vergleichsoperatoren in Perl 

Numerische Vergleiche:

      Operator	Bedeutung

	==	ist wahr bei genauer Gleichheit
	!=	ist wahr bei Ungleichheit
	>	ist wahr wenn der linke Wert groesser dem rechten ist
	<	ist wahr wenn der linke Wert kleiner dem rechten ist
	>=	ist wahr wenn der linke Wert groesser oder gleich dem rechten ist
	<=	ist wahr wenn der linke Wert kleiner oder gleich dem rechten ist
	

Zeichenkettenvergleiche:

     Operator	Bedeutung

	eq	ist wahr bei Gleichheit
	ne	ist wahr bei Ungleichheit
	gt	ist wahr wenn linker Wert größer dem rechten
	lt	ist wahr wenn linker Wert kleiner dem rechten
	ge	ist wahr wenn linker Wert größer oder gleich dem rechten
	le	ist wahr wenn linker Wert kleiner oder gleich dem rechten

Literatur 

Larry Wall & Randal L. Schwartz:
Programming Perl, 2nd Edition
O'Reilly & Associates, Inc.
ISBN 1-56592-6

Randal L. Schwartz:
Einführung in PERL
O'Reilly International Thomson Verlag
ISBN 3-930673-08-8

Perl Quick Reference: http://www.pcnet.com/~rhswain/perl.html

Perl FAQ: http://www.perl.com/perl/faq/index.html

Perl CGI Programming FAQ: http://www.perl.com/perl/everything_to_know/index.html

Perl OOP Tutorial: http://www.perl.com/perl/all_about/perltoot.html

Der Autor

Achim Schmidt ist staatlich geprüfter Assistent für Automatisierungs- und Computertechnik (HBFS) und beschäftigt sich bereits seit 6 Jahren intensiv mit dem Internet und seinen Diensten. Mit Linux wurde er erstmalig 1992 beim Aufbau eines Mailboxsystemes direkt konfrontiert. Seit 1993 sind bereits einige Publikationen (http://www.saar.de/~as/publications/) von ihm in verschiedenen Medien erschienen . Seit 1995 ist er als Netzwerk- und Systemmanager tätig und beschäftigt sich dabei auch mir der Entwicklung und Realisierung WWW- basierter Onlinesysteme und Internetkopplungen. Zu erreichen ist er unter as@Saar.DE.

Copyright © 1997 Linux-Magazin Verlag