Aus Ubuntu-Forum Wiki

Artikel in Bearbeitung

Um Versions-Konflikte zu vermeiden, darf er nicht geändert werden, so lange dieser Hinweis erscheint!

1 Grundinformationen zu Perl

Perl ist eine plattformunabhängige und freie Programmiersprache, welche oft für kleinere Skripte benutzt wird.

Die Grundlagen von Perl sind vergleichsweise einfach zu erlernen, jedoch bietet Perl auch für fortgeschrittene Benutzer einiges. So zeichnen sich Programme, die mit Perl erstellt worden sind, durch ihre Schnelligkeit und Portierbarkeit aus. Auch die grafische Programmierung ist mittels TK, GTK und QT unter Perl möglich.

Die erste Version von Perl wurde 1987 veröffentlicht und besaß Elemente aus: Ada, Basic, C, Pascal und dem Unix-Bereich. Perl wiederum beinflusste später grundlegend die Programmiersprachen: JavaScript, PHP, Python und Ruby.

Das Motto von Perl lautet: "TIMTOWTDI" ("There IS More Than One Way To Do It : Viele Wege führen zum Ziel")

Merke: Perl != (ungleich) Pearl!
Pearl ist eine Sprache die schon seit 1970 in Deutschland entwickelt wurde und hauptsächlich
in der Prozessteuerung eingesetzt wird.

Diese Anleitung wurde speziell für Perl-Einsteiger erstellt und hat das Ziel dem Leser die Grundlagen von Perl aufzuzeigen. Durch eine Menge Zusatzinformationen in den einzelnen Kapiteln, ist diese Lektüre auch für fortgeschrittene Programmierer lesenswert.

2 Installation

Um unter Ubuntu mit Perl programmieren zu können, müssen folgende Pakete herunterladen und installiert werden:

• perl
• perl-modules
• perl-base
• perl-doc (Optional)

Herunterladen und installieren über apt-get:

sudo apt-get install perl perl-modules perl-base perl-doc

Zudem ist ein Editor, der die Sprache Perl über Syntax-Hervorhebung und Verschachtelung von Programmabschnitten unterstützt, sehr zu empfehlen. Es gibt auch Entwicklungsumgebungen, wie z.B. Eclipse, die die Programmierung mit Perl nicht nur unterstützen, sondern sogar deutlich vereinfachen.

Mehr dazu unter: Programmieren und Editor

Alternativ kann Perl auch von der Internetpräsenz: perl.com heruntergeladen und kompliiert werden.

3 Ausführen von Perl-Skripten

Ein Perl-Skript speichert man standardmäßig mit der Endung: ".pl" ab. Zusätzlich benötigt der Benutzer unter Linux(Unix)-Systemen Berechtigungen um dieses Skript auch ausführen zu dürfen.

Die Ausführberechtigung kann für den aktuellen Benutzer folgendermaßen vergeben werden:

chmod u+x hallowelt.pl

Sollten Sie sich außerhalb des eigenen Heimatverzeichnisses befinden, muss der Befehl als SuperUser ausgeführt werden:

sudo chmod u+x hallowelt.pl

Nun kann das Skript über einen der folgenden Befehle, aus der Konsole heraus aufgerufen werden:

./hallowelt.pl
perl hallowelt.pl

4 Perl Anleitung

Diese Anleitung hat das Ziel, Ihnen die Grundlagen und das wichtigste Hintergrundwissen der Programmiersprache Perl beizubringen. Obwohl diese Anleitung in einem Wiki zum Betriebssystem Ubuntu veröffentlicht wurde, kann diese Anleitung auch unter anderen Unix-artigen Betriebssystemen und sogar teilweise unter Windows verwendet werden.

4.1 Vorwort

PLATZHALTER

4.2 Der Einstieg

Mithilfe von den nachfolgenden Übungen, werden Sie einen tiefer greifenden Einblick in die Perl-Programmierung bekommen. Sie werden unter anderem lernen wie man Benutzereingaben ausliest, Subroutinen erstellt, verschiedene Arten von Schleifen programmiert und wie man bestehende Module für eigene Zwecke nutzen kann.

Wenn Sie eine Aussage in dieser Anleitung einmal nicht verstehen sollten, schauen Sie sich diese nocheinmal in Ruhe an, da ich es manchmal beabsichtige, den Leser zum Nachdenken zu bewegen!

Am Ende jedes Abschnittes erhalten Sie zusätzlich noch weiterführende Links zu dem aktuellen Thema, falls Sie mehr darüber erfahren möchten.

Alle Skripte wurden unter:

• Ubuntu 8.04 (Hardy Heron)
• Ubuntu 7.10 (Gutsy Gibbon)
• Ubuntu 7.04 (Feisty Fawn)
• Debian 4.0 (Etch)

und der Perl-Version 5.8.8 getestet.

Diese Anleitung ist für Programmier-Anfänger geeignet, jedoch sollten einige Grundkenntnisse im Umgang mit GNU/Linux gegeben sein.

In dieser Anleitung werden Ihnen die Programmierstandards von Perl aufgezeigt, welche unabdingbar für qualitativ hochwertige Skripte sind. Gerade bei der Weitergabe von Skripten, sollten die nachfolgenden Hinweise angewandt werden um eine spätere Wartung und Erweiterung zu vereinfachen, auch wenn die Einhaltung dieser Standards manchmal sehr Zeitaufwendig ist.

4.3 Kapitel 1: Hallo Welt

Wie unter fast jeder Programmiersprache werden Sie als erstes das Hallo Welt-Programm kennenlernen:

#!/usr/bin/perl
 
use strict;
use warnings;
 
print "Hallo Welt\n";

Dieses Skript gibt ein "Hallo Welt" auf dem Bildschirm aus und beendet sich danach selbst.

Die Zeile #!/usr/bin/perl nennt man die Shebang-Zeile, sie gibt an, wo sich der Interpreter für die jeweilige Skript-Sprache befindet, unter Ubuntu ist dieser Standardweise unter /usr/bin/perl zu finden.

Zusätzlich fügen die meisten Perl-Programmierer unter der Shebang-Zeile eine weitere Zeile ein, welche den Programmnamen und den Namen des Autors enthält. Hier mal ein Beispiel:

#!/usr/bin/perl
# HalloWelt.pl -- by Ubuntu-Forum
 
use strict;
use warnings;
 
print "Hallo Welt\n";

Wie Sie sich höchstwahrscheinlich schon gedacht haben, leitet ein Raute-Zeichen (#) in Perl einen Kommentar ein. Alles was in einer Zeile hinter diesem Zeichen steht, wird vom Perl-Interpreter nicht beachtet und bietet dem Entwickler die Möglichkeit Hinweise in das Skript einfließen zu lassen. (Die Shebang-Zeile ist dabei eine Ausnahme)

Gerade bei größeren Skripten, sollten kompliziertere Anweisungen gut auskommentiert werden.

Die Zeilen use strict und use warnings bezeichnen zwei Pragmas, die in unser Skript eingebunden werden. Da diese beiden Pragmas für das Entwickeln von qualitativ hochwertigen Skripten wichtig sind, finden Sie am Ende dieses Kapitels zwei Abschnitte zu den Pragmas.

Mit dem Befehl print können wir nun einen beliebigen Text auf dem Bildschirm ausgeben. Der Backslash-Escape: "\n" bewirkt, dass hinter dieser Ausgabe ein Zeilenumbruch geschieht.

4.3.1 Backslash-Escapes

Backslash-Escapes kann man in print-Befehlen an beliebiger Stelle einfügen. Es folgt eine Auflistung der wichtigsten Backslash-Escapes und deren Auswirkungen auf Ihr Programm:

Weitergehende Informationen:

• cpan Ausführliche Dokumentation der Backslash-Escapes

4.3.2 Pragmas

Pragmas können mit einem use <PRAGMANAME>, genau wie Module auch in Skripte eingebunden werden. Pragmas auch pragmatic modules genannt sind jedoch keine richtigen Module, sie teilen im Gegensatz zu den Modulen "nur" dem Compiler mit, wie er mit dem Quellcode umzugehen hat. Ein Pragma erkennt man daran, dass es klein geschrieben wird. Ein Modul jedoch besitzt mindestens einen großen Buchstaben.

4.3.2.1 Pragma strict

Das Pragma strict sorgt dafür, dass grundlegende Programmierregeln unter Perl eingehalten werden. Auch wenn das Programm problemlos läuft zeigt dieses Pragma eventuelle Fehler im Programmcode an. Ein Beispiel wäre da z.B. eine nicht deklarierte Variable / Skalar. (Im Abschnitt: Skalare wird diese Problematik noch erläutert)

Das Pragma kann man durch ein:

use strict;

in sein Programmcode einbinden. Ich würde ihnen als Anfänger empfehlen von Anfang an mit dem strict-Pragma zu arbeiten, damit sie später keine Probleme haben "sauber" zu programmieren.

4.3.2.2 Pragma warnings

Mit dem Pragma warnings werden die Warnungen für das jeweilige Programm eingeschaltet. Wir können das Pragma durch ein:

use warnings;

in den Programmcode einbinden. Ohne diese Warnungen kann es vorkommen das Perl auch im Grunde falschen Code ausführt. Ein Beispielfehler wäre z.B. eine Variable innerhalb eines Arrays, mit @array[1] anstatt $array[1] anzusprechen. (Keine Sorge, wenn Sie dies noch nicht verstehen können sie ruhig bei dem Thema Arrays hierher zurückkehren)

Auch die regelmäßige Verwendung des warning-Pragmas wird empfohlen.

4.3.3 Optionen in der Shebang-Zeile

Mithilfe von Argumenten in der Shebang-Zeile ist es möglich dem Interpreter mitzuteilen, wie er (ähnlich wie bei den Pragmas) den Programmcode zu übersetzen hat.

Um die Warnungen für ein Skript einzuschalten können wir entweder:

 use warnings;

eintippen oder der Shebang-Zeile den Parameter -w anhängen:

#!/usr/bin/perl -w

Es folgt eine Auflistung der wichtigsten zulässigen Optionen in der Shebang-Zeile:

Weitergehende Informationen:

• Wikipedia Grundinformationen zu der Shebang-Zeile allgemein

4.4 Kapitel 2: Der Umgang mit Skalaren

Eine Variable ist ein Platzhalter im Arbeitsspeicher, der für jeden Text oder Wert stehen kann.

Die Variablen unter Perl werden auch als Skalare bezeichnet und werden mit einem Dollar ($)-Zeichen gekennzeichnet. Einen Skalar deklariert man mit einem "my" vor dem Skalarnamen.

Ein Beispiel zur Veranschaulichung:

#!/usr/bin/perl
use strict;
use warnings;
 
my $name = "Otto";
print "Mein Name ist: $name\n";

In diesem Beispiel wird der Skalar $name in der 4 Zeile des Skripts deklariert und initialisiert. (Dem Programm bekannt gemacht und einem Wert zugewiesen)

Würde man das "use strict;" weglassen könnte man auch eine Variable ohne Deklaration benutzen.

Zum Beispiel so:

#!/usr/bin/perl
$name= "Otto";
print "Mein Name ist: $name\n";

Schauen wir uns noch ein anderes Skript an:

#!/usr/bin/perl
# skalare.pl -- by Ubuntu-Forum
 
use strict;
use warnings;
 
print "Bitte geben Sie Ihren Namen ein:\n";
my $eingabe = <STDIN>;
print "Hallo $eingabe\n";

Dieses Programm wartet auf eine Benutzereingabe, die dann in den Skalar $eingabe eingelesen wird. Danach kann der Benutzer durch das Auslesen des Skalars mit seinem Namen begrüßt werden.

Neu an diesem Programm ist unter anderem die Zuweisung:

my $eingabe = <STDIN>;

Dabei wird dem neuen Skalar $eingabe, eine benutzerdefinierte Eingabe, die durch das Dateihandle: STDIN aufgerufen wird, zugeordnet.

Ein Dateihandle nennt man eine I/O-Verbindung (Input-Output -Verbindung) zwischen Ihrem Programm und Ihrem System. Beim Aufruf von STDIN wird auf den Standardeingabekanal zugegriffen. (Dies ist meist die Tastatur des Benutzers, kann jedoch auch in speziellen Fällen eine Datei oder eine Pipeline sein) Weiteres dazu finden Sie noch in der Begriffserklärung zu STDIN und den Dateihandles!

Dieser Skalar wird durch den print-Befehl in der Zeile 9 wieder ausgegeben. Geben wir nun den ganzen Code mit den einfachen Anführungszeichen (') anstatt den doppelten Anführungszeichen (") ein, so sehen wir, dass Sonderzeichen einfach mit ausgegeben werden und so die Variable nicht erkannt wird:

#!/usr/bin/perl
# skalare.pl -- by Ubuntu-Forum
 
use strict;
use warnings;
 
print "Bitte geben Sie Ihren Namen ein:\n";
my $eingabe = <STDIN>;
print 'Hallo $eingabe';

Die Ausgabe ergibt:

Hallo $eingabe

Sie sehen also, dass alles was in den einfachen Anführungszeichen steht, als reiner Text interpretiert wird. Um den Inhalt der Variable auszugeben muss also entweder der Skalar in doppelten Anführungzeichen (") geschrieben werden, oder aber der Skalar wird mit einem Punkt an dem Text angefügt. Beispiel:

print 'Hallo' . $eingabe;

Jedoch müssen wir nicht immer einen neuen Teil an den print-Befehl anhängen, wenn wir z.B. ein Sonderzeichen in doppelten Anführungszeichen (") einfügen wollen. Um das Zeichen trotzdem richtig anzeigen zu lassen, müssen wir es vorher nur richtig deklarieren. Dies geschieht mit dem \ -Zeichen. Um z.B. ein Dollarzeichen vor die Begrüßung zu stellen, geben wir Folgendes ein:

print "\$ Hallo $eingabe";

Die Ausgabe mit dem Inhalt des Skalars: $eingabe = Otto ergibt:

$ Hallo Otto

Weitergehende Informationen:

• selfhtml.org/perl Grundinformationen zu dem Umgang mit Skalaren unter Perl

4.5 Kapitel 3: if-Abfragen

IF-Anweisungen sind unabdingbar für das Programmieren unter Perl. Mit ihnen kann man z.B. auf Benutzerreaktionen reagieren und spezielle Daten abfragen.

Eine IF-Anweisung ist wie folgt aufgebaut:

if (BEDINGUNG)
{
  AKTION
}
# WENN (BEDINGUNG) { DANN TUE DIES (AKTION) }
elsif (BEDINGUNG)
{
  AKTION
}
# WENN SONST (BEDINGUNG) { DANN TUE DIES (AKTION) }
else
{
  AKTION
}
# ANDERNFALLS { TUE DIES (AKTION) }

Dabei kann die else if- und else-Bedingung bei Bedarf eingefügt werden,sie ist jedoch nicht essentiell.

Erweitern wir nun unser Begrüßungsprogramm um eine IF-Anweisung, welche abfragt ob der Benutzer überhaupt seinen Namen eingegeben hat:

#!/usr/bin/perl
# Abfrage.pl -- by Ubuntu-Forum
 
use strict;
use warnings;
 
print "Bitte geben sie Ihren Namen ein!:";
my $eingabe = <STDIN>;
chomp($eingabe);
if ($eingabe)
{
  print "Hallo, $eingabe!\n";
}
else
{
  print "Sie haben nichts eingegeben!\n";
}

Gucken wir uns zuerst die Bedingungen in diesem Code an:

if ($eingabe)
{
  print "Hallo, $eingabe!\n";
}
else
{
  print "Sie haben nichts eingegeben!\n";
}

Dies bedeutet gekürzt soviel wie:

Wenn die Eingabe erfolgt ist --> Begrüße den Benutzer

Wenn dies nicht der Fall ist --> Fehlermeldung: Sie haben nichts eingegeben!

Dabei fragt der Code:

if ($eingabe)

ab, ob die Variable $eingabe einen Inhalt besitzt. Alternativ können Sie auch:

if ($eingabe ne "")

was soviel wie: Wenn die Variable $eingabe ungleich nichts ist dann... bedeutet

nutzen, wobei die erste Variante aber bequemer sein sollte. Doch wofür ist nun das: chomp($eingabe) gut?

Bei der Abfrage der Benutzereingabe mittels <STDIN> muss die Eingabe immer durch ein Enter betätigt werden, dies fügt damit gleichzeitig einen zusätzlichen Zeilenumbruch in unsere Variable ein, sodass wir nie keine Eingabe tätigen können, sondern immer mindestens einen Zeilenumbruch in der Variable haben.

Der Befehl chomp filtert nun alle Zeilenumbrüche am Ende eines Skalars oder eines Arrays heraus. Zum ausprobieren können Sie einmal versuchen was passiert, wenn der chomp-Befehl in diesem Beispiel weggelassen wird.

4.5.1 Vergleichsoperatoren bei Zahlen

Beispiel:

Ist die Variable: $zahl1 gleich 5?:

#!/usr/bin/perl
 
use warnings;
use strict;
 
print "Bitte geben Sie eine Zahl ein:\n";
my $zahl1 = <STDIN>;
 
if($zahl1 == 5)
{
  print "Zahl ist gleich 5!\n";
}
else
{
  print "Zahl ist ungleich 5!\n";
}

4.5.2 Vergleichsoperatoren bei Zeichenketten (Strings)

Beispiel:

Ist der Inhalt, der Variable $name gleich Otto?:

#!/usr/bin/perl
 
use warnings;
use strict;
 
print "Bitte geben Sie Ihren Namen ein:\n";
my $name = <STDIN>;
 
if($name eq "Otto")
{
  print "Hallo Otto wie gehts?\n";
}
else
{
  print "Du bist nicht Otto!\n";
}

4.6 Kapitel 4: Rechnen mit Perl

Rechnungen gestalten sich in Perl meist sehr einfach, so braucht man z.B. für eine einfache Addition nur folgenden Code eintippen:

#!/usr/bin/perl
#rechner.pl -- by Ubuntu-Forum
 
use strict;
use warnings;
 
my $zahl1 = "5";
my $zahl2 = "10";
my $ergebnis = $zahl1 + $zahl2;
print $ergebnis . "\n";

Als Operator für die Addition wird also einfach ein Plus (+)-Zeichen verwendet. Um nun einen Taschenrechner zu programmieren der multiplizieren kann, muss einfach der Rechenoperator * verwendet werden.

#!/usr/bin/perl
 
use strict;
use warnings;
 
print "Geben Sie die erste Zahl ein:\n";
my $zahl1=<STDIN>;
print "Geben Sie die zweite Zahl ein:\n";
my $zahl2=<STDIN>; 
$ergebnis = $zahl1 * $zahl2;
print "\nDas Ergebnis ist: $ergebnis\n";

Zusätzlich gibt es noch folgende andere Rechenoperatoren:

4.6.1 Rechenoperatoren

4.7 Kapitel 5: Schleifen

Unter Perl gibt es wie in vielen anderen Programmiersprachen verschiedene Arten von Schleifen. Darunter zählen unter anderem:

• while-Schleifen
• do/while-Schleifen
• for-Schleifen
• foreach-Schleifen

4.7.1 while-Schleife

Wir schreiben uns nun ein kleines Programm, welches von 0 an beliebig weit hochzählen kann.

 #!/usr/bin/perl
 # while.pl -- by Ubuntu-Forum
 
 use strict;
 
 print "Geben sie ein Ende ein: \n";
 my $ende = <STDIN>;
 my $count = 0;
 
 while ($count <= $ende)
 {
 	print $count . "\n";
 	$count ++;
        sleep(1);
 }

Anmerkung: Das use warnings; wurde in diesem Skript extra weggelassen.
Um zu wissen warum können Sie es ja einmal hinzufügen und einen Buchstaben als Ende ($ende) eingeben.

Duch das Filehandle: <STDIN> bestimmt der Benutzer also selbst wie hoch das Programm zählen soll. Eine while-Schleife ist folgendermaßen aufgebaut:

 while(BEDINGUNG)
 {
   AKTION
 }

Der Befehl $count++; zählt den Wert der Variable $count um eine Stelle hoch (+ 1), alternativ könnte man auch

 $count = $count + 1;

oder

 $count += 1;

schreiben.

Mit sleep(1); stoppen wir die while-Schleife um genau eine Sekunde.

Die while-Schleife ist die einfachste Schleifenart unter Perl, sie wird solange durchlaufen, wie Ihre Bedingung erfüllt wird. Da die einfache while-Schleife eine Kopfgesteuerte Schleife ist, kann es jedoch vorkommen das die Bedingung garnicht im Programm erfüllt wird und die Schleife niemals startet.

4.7.2 do/while-Schleife

Die do/while-Schleife ist die einzige fußgesteuerte Schleifenart die es unter Perl gibt! Das besondere daran ist, dass dadurch die Schleife mindestens einmal durchlaufen wird, auch wenn die while-Bedingung garnicht erfüllt wird.

Eine do/while-Schleife ist wie folgt aufgebaut:

 do
 {
   ANWEISUNG;
 } while (BEDINGUNG);

Wir vervollständigen nun unseren Code der einfachen while-Schleife um eine zusätzliche Abfrage am Ende des Programmes, ob das Skript neugestartet werden soll oder nicht.

 #!/usr/bin/perl
 # do_while.pl -- by Ubuntu-Forum
 
 use strict;
 my $antwort;
 
 do 
 {  
   print "Geben Sie ein Ende ein: \n";
   my $ende = <STDIN>;
   my $count = 0;
 
   while ($count <= $ende)
   {
     print $count . "\n";
     $count ++;
     sleep(1);
   }
   print "Wollen Sie das Programm neustarten [j][n]?\n";
   $antwort = <STDIN>;
   chomp($antwort);
 } while ($antwort ne "n");

Die do-Schleife wird in diesem Code solange durchlaufen bis die Variable $antwort den Wert "n" hat. Doch auch bei eingabe eines "u" wird jetzt das Programm neugestartet bzw. wiederholt.

Das Besondere an einer do-while Schleife ist, dass sie immer mindestens einmal durchlaufen wird, auch wenn die Bedingung für die Schleife garnicht erfüllt wird.

Dies können wir gut veranschaulichen, indem wir unser Programm ein wenig verändern:

 #!/usr/bin/perl
 # do_while.pl -- by Ubuntu-Forum
 
 use strict;
 my $antwort = "n";
 
 do
 {
   print "Geben Sie ein Ende ein: \n";
   my $ende = <STDIN>;
   my $count = 0;
 
   while ($count <= $ende)
   {
     print $count . "\n";
     $count ++;
     sleep(1);
   }
   print "Wollen Sie das Programm neustarten [j][n]?\n";
   $antwort = <STDIN>;
   chomp($antwort);
 } while ($antwort ne "n");

Wir haben nun der Variable $antwort direkt beim Start des Programmes den Wert "n" gegeben. Obwohl die Schleife als Bedingung hat, das $antwort ungleich "n" sein soll, durchläuft sie die Schleife einmal.

4.7.3 for-Schleife

Schreiben wir uns zuerst ein Beispielprogramm, welches mithilfe der for-Schleife eine Zahl hochzählt.

 #!/usr/bin/perl
 
 use strict;
 use warnings;
 
 for (my $count = 0; $count <= 100; $count++)
 {
   print "$count\n";
 }

Zur Erklärung hier einmal der Syntax der for-Schleife:

 for (INITIALISIERUNG; BEDINGUNG; INKREMENT)
 {
   AKTION;
 }

In unserem Beispielprogramm weisen wir der neuen Variable $count also eine 0 zu, dass ist die Initialisierung. --> my $count = 0;

Die Schleife soll solange durchlaufen werden, wie der Wert der Variable $count kleiner gleich 100 ist. Wie Sie sich sicher denken können ist dies die Bedingung --> $count <= 100;

Jedes mal wenn die Schleife durchlaufen wird, soll der Variable $count eine eins hinzuaddiert werden, dies nennt man das Inkrement --> $count++

Die for-Schleife wird verwendet, wenn vorher bekannt ist wie oft diese Schleife durchlaufen wird!

4.7.4 foreach-Schleife

Die foreach-Schleife kann synonym zur for-Schleife benutzt werden. Dabei findet die Programmiersprache Perl selbständig anhand der Semikolons in den Klammern heraus ob es sich um eine for- oder eine foreach-Schleife handelt.

Hier mal ein Beispiel:

 #!/usr/bin/perl
 
 use strict;
 use warnings;
 
 for (1..100)
 {
   print "$_\n";
 }

Zuerst werden Sie feststellen, dass diese Schleifenart im Vergleich zu der for-Schleife viel kürzer und auch einfacher ist.
(die Rede ist natürlich nur von diesem Beispiel)

Die Variable $_ gibt in diesem Beispiel immer den aktuellen Zählerstatus der foreach-Schleife aus.

Grundlegend erkennt man eine for-Schleife an den zwei Semikolons (;), in den Klammern nach dem for:

 for (*;*;*)

Während eine foreach-Schleife folgendermaßen aufgebaut ist:

 for (*)

oder:

 foreach (*)

Es macht dabei keinen Unterschied ob man nun:

 for (1..100)

oder auch:

 foreach (1..100)

schreibt, man sollte sich jedoch die Schreibweise mit foreach angewöhnen, da man daran dann direkt erkennen kann, um welche Schleifenart es sich handelt.

4.8 Kapitel 6: Der Umgang mit Arrays

4.8.1 Zweidimensionale Arrays

4.8.2 Aufgabe: Der Umgang mit Arrays

Bevor sie dieses Kapitel bearbeiten, sollten Sie vorerst die Begriffserklärung zu den Arrays gelesen haben.

Versuchen Sie nun einmal ein Programm zu schreiben, welches es ermöglicht beliebig viele Werte in ein Array zu schreiben und hinterher abzurufen.

Der Programmablauf sollte Grundlegend ungefähr so aussehen:

1. Textausgabe: "Geben Sie die Anzahl der gewünschten Datensätze ein."

2. Benutzerabfrage: "Gewünschte Datensätze". 

3. Textausgabe: "Geben Sie den Inhalt des Datensatzes Nummer: 1 ein!"

4. Benutzerabfrage: "Datensatz 1".

3. Textausgabe: "Geben Sie den Inhalt des Datensatzes Nummer: 2 ein!"

4. Benutzerabfrage: "Datensatz 2".

... Einlesen aller Datensätze ...

5. Textausgabe: "Ihre Eingaben waren:"

...1. --> x

...2. --> x

...

6. Textausgabe: "Wollen Sie das Programm neu starten?"

7. Benutzerabfrage: "Beenden / Wiederholen".

Versuchen Sie diese Aufgabe ersteinmal alleine zu lösen und greifen Sie nur im Notfall auf das Beispielprogramm zu.

Lassen Sie sich ruhig Zeit und greifen Sie wenn nötig auf eine vorherige Übung zurück.

4.9 Kapitel 7: Subroutinen

Subroutinen sind ein wichtiger Bestandteil von Perl, mit diesen Routinen ist es möglich benutzerdefinierte Funktionen zu erstellen.

Subroutinen werden mit einem sub eingeleitet und sind folgendermaßen aufgebaut:

 sub FUNKTIONS-NAME
 {
    AKTION;
 }

Eine vorhandene Subroutine können wir mit einem Und-Zeichen (&) und dem Namen der Funktion aufrufen:

 &meineerstefunktion;

Nun programmieren wir uns einmal ein kleines Additionsprogramm für unsere erste Funktion:

#!/usr/bin/perl
 
use strict;
use warnings;
 
print "Geben Sie den ersten Wert an: "; 
my $zahl1 = <STDIN>;
 
print "Geben Sie den zweiten Wert an: ";
my $zahl2 = <STDIN>;
 
print "\n\tIhr Ergebnis lautet: ";
print &addieren . "\n";
 
sub addieren
{
  return $zahl1 + $zahl2;
}

Das Programm liest nun die beiden Variablen $zahl1 und $zahl2 ein und greift danach auf die Funktion "addieren" zu.

Eine Funktion besitzt immer einen oder mehrere Rückgabewerte, diese erkennt Perl automatisch, sodass wir das return in unserer Funktion: "addieren" eigentlich auch weglassen können. Es ist jedoch für Anfänger zu empfehlen, dass return trotzdem zu verwenden. (dies hilft auch bei größeren Skripten mit mehreren Funktionen die Übersicht zu bewahren)

Für diejenigen die Ihre Funktionen lieber im Programmkopf vor der eigentlichen Variablendefinition schreiben, kommt der obere Code nicht in Frage. Um das zu ermöglichen müssen wir die Variablen in der Funktion vorzeitig verfügbar machen:

#!/usr/bin/perl
 
use strict;
use warnings;
 
sub addieren
{
  my ($zahl1, $zahl2) = @_;
  return $zahl1 + $zahl2;
}
 
print "Geben Sie den ersten Wert an: ";
my $zahl1 = <STDIN>;
 
print "Geben Sie den zweiten Wert an: ";
my $zahl2 = <STDIN>;
 
print "\n\tIhr Ergebnis lautet: ";
print addieren($zahl1,$zahl2) . "\n";

Da wir in der Funktion: "addieren" auf die noch nicht vorhandenen Variablen $zahl1 und $zahl2 zugreifen, müssen wir diese bei dem Aufruf der Funktion mitübergeben:

 print addieren($zahl1,$zahl2) . "\n";

In der Funktion selber müssen wir zusätzlich auch noch angeben, dass der Funktion mit dem Aufruf zwei Variablen übergeben werden:

 my ($zahl1, $zahl2) = @_;

Meist ist es sinnvoller diese Möglichkeit zu verwenden, um die Funktionen in den Programmkopf schreiben zu können.

4.9.1 Aufgabe: Zahlenraten

Ihre Aufgabe ist es nun ein simples Zahlenspiel zu programmieren, in dem der Benutzer eine zufällige Zahl zwischen 1 und 100 in möglichst wenigen Versuchen herausfinden muss. Das Programm teilt dem Benutzer lediglich mit ob die Zufallszahl größer oder kleiner wie der abgegebene Tipp ist.

Eine Zufallszahl zwischen 1 und 100 können wir mithilfe von:

 int(rand(100));

erzeugen, genaueres zu diesem Befehl wird in dem Lösungsvorschlag beschrieben.

Es bleibt Ihnen dabei selbst überlassen wie Sie das Programm realisieren, ich gebe Ihnen nur ein paar Ansatzpunkte welche möglichst beachtet werden sollten:

• Es muss mindestens eine Funktion in dem Programm eingebunden sein
• Im Programm sollte ein Zähler, welcher die gebrauchten Versuche anzeigt vorhanden sein

Wenn Sie die Aufgabe erledigt haben, können Sie ihr Programm ja einmal mit dem Beispielprogramm vergleichen.

4.10 Übung 7: Diamantoperatoren

Mithilfe der Diamantoperatoren können wir unsere Programme mit Argumenten starten, dass kennen Sie wahrscheinlich von dem Editor nano welchen wir mit dem Argument der Datei starten:

sudo nano /etc/X11/xorg.conf

Diese Argumente können in Variablen eingelesen und im Programm genutzt werden.

4.10.1 Begrüßungsprogramm mit Diamantoperatoren

Um zu sehen was genau Diamantoperatoren sind und wie man diese einbindet, erweitern wir uns zuerst einmal, dass Begrüßungsprogramm vom Anfang dieser Anleitung:

 #!/usr/bin/perl
 #begruessung.pl -- by Ubuntu-Forum
 
 use strict;
 use warnings;
 
 my $eingabe = $ARGV[0];
 
 if ($eingabe)
 {
   print "Hallo, $eingabe!\n"; }
 else
 {
   print "Sie haben nichts eingegeben!\n";
 }

Die Variable ($ARGV) ist eine Umgebungsvariable die in der Lage ist die Diamantoperatoren auszulesen. In unserem Beispiel lesen wir den ersten Operator aus ("0").
Merke: In der Informatik fängt man ab 0 an zu zählen!

Wenn wir nun zwei Argumente mithilfe der Kristalloperatoren dem Programm übergeben wollen, damit wir das Begrüßungsprogramm folgendermaßen nutzen können:

./begruessung.pl Otto Karl

müssen wir auch den zweiten Operatoren ("1") auslesen:

 #!/usr/bin/perl
 #begruessung.pl -- by Ubuntu-Forum
 
 use strict;
 use warnings;
 
 my $eingabe1 = $ARGV[0];
 my $eingabe2 = $ARGV[1];
 
 if ($eingabe1 && $eingabe2)
 {
   print "Hallo, $eingabe1 und $eingabe2\n";
 }
 else
 {
   print "Die Eingabe ist fehlerhaft!\n";
 }

Die Diamantoperatoren werden hier durch:

 my $eingabe1 = $ARGV[0];
 my $eingabe2 = $ARGV[1];

ausgelesen und können noch um weitere Eingaben erweitert werden. In den folgenden Kapiteln wird das Starten eines Perl-Programmes mithilfe von Argumenten noch weiter behandelt!

4.10.2 Aufgabe: Taschenrechner

Nehmen Sie sich nun ein wenig Zeit und programmieren Sie einen Taschenrechner, welcher 2 Werte miteinander Addieren, Subtrahieren, Multiplizieren und Dividieren kann.

Die Eingabe soll wie folgt über Diamantoperatoren geschehen:

./rechner.pl wert1 operator wert2
Ein Beispiel:
./rechner.pl 5 + 4

Versuchen Sie nicht sofort aufzugeben und wenden Sie das bisher gelernte in diesem Programm an.

Lösungsvorschlag: Perl/Taschenrechner

4.11 Übung 8: Dateizugriffe mit Perl

Um auf eine Datei auf beliebiger Art zugreifen zu können, müssen wir Dateihandles verwenden.

Bei diesen Dateihandles wird von vornerein angegeben für welchen Zweck die Datei geöffnet werden soll (Lesen, Neu anlegen, Hinzufügen...), dabei ist natürlich auf die Rechtevergabe für die ausgewählte Datei zu achten.

Beim Verändern einer Systemdatei durch ein Perl-Skript muss dieses folglich mit root-Rechten gestartet werden.

4.11.1 Lesender Zugriff

Wir wollen uns nun ein Programm schreiben, welches den Dateiinhalt einer benutzerdefinierten Datei ausliest und auf dem Standartausgabekanal ausgibt.

#!/usr/bin/perl
# auslesen.pl -- by Ubuntu-Forum 
 
use strict;
use warnings; 
 
my $datei = $ARGV[0];
 
open(DATEI, "<$datei") || die "Fehler: $!";
  while(<DATEI>)
  {
    print $_;
  }
close DATEI;

Wenn wir das Programm nun über:

./auslesen.pl /etc/X11/xorg.conf

zeigt uns das Programm den Inhalt der Konfigurationsdatei an.

Wir sehen also das das "<" - Zeichen für den lesenden Zugriff verantwortlich ist. Mit der while-Schleife arbeiten wir die Datei zeilenweise ab und schreiben diese, mithilfe der Ausgabe- Variable ($_) in den Standartausgabekanal.

Am Ende müssen wir unser jeweiliges Dateihandle immer schließen.

4.11.2 Schreibender Zugriff

Wie Dateien ausgelesen werden, wurde ja schon in dem vorhergehenden Abschnitt geklärt, um jedoch nun eine neue Datei mit Benutzerdefiniertem Inhalt zu erstellen oder eine bestehende Datei mit Inhalt zu überschreiben, müssen wir andere Mittel unter Perl einsetzen:

 #!/usr/bin/perl
 # schreiben.pl -- by Ubuntu-Forum 
 
 use strict;
 use warnings; 
 
 my $datei = $ARGV[0];
 print "\tGeben Sie einen Inhalt an:\n";
 chomp(my $inhalt = <STDIN>);
 
 open(DATEI, ">$datei") || die "Fehler: $!";
   print DATEI $inhalt;
 close DATEI;

Um eine neue Datei mit Inhalt zu erstellen oder eine bestehende Datei mit neuem Inhalt überschreiben zu können, verwenden wir das Größer als- Zeichen beim Öffnen des Dateihandles.

Damit wir in das Dateihandle schreiben können, verwenden wir den bekannten print- Befehl und dahinter den zu verwendenen Dateihandle.

4.11.3 Hinzufügender Zugriff

Da wir unsere schon bestehenden Daten in einer Datei nicht immer überschreiben wollen, besteht auch die Möglichkeit, Daten einer Datei hinzuzufügen.

 #!/usr/bin/perl
 # hinzufuegen.pl -- by Ubuntu-Forum 
 
 use strict;
 use warnings; 
 
 my $datei = $ARGV[0];
 print "\tGeben Sie einen Inhalt an:\n";
 chomp(my $inhalt = <STDIN>);
 
 open(DATEI, ">>$datei") || die "Fehler: $!";
   print DATEI $inhalt;
 close DATEI;

Um in eine Datei, Daten hinzuzufügen verwenden wir folglich zwei Größer als- Zeichen (">>"). Der restliche Code, müsste anhand der vorherigen beiden Kapiteln verständlich sein.

4.12 Suchen und Ersetzen

Natürlich besteht unter Perl auch die Möglichkeit, eine bestimmte Zeichenfolge zu Suchen und auch zu ersetzen.

4.12.1 Suchen

Um eine Variable auf ein beliebiges Muster zu überprüfen, kann folgender Codeausschnitt verwendet werden.

#!/usr/bin/perl
use strict;
use warnings;
 
print "Geben Sie Ihre Daten ein:\n";
$_ = <STDIN>;
 
if (/blub/) {
  print "In Ihrem Text ist das Wort: blub enthalten!\n"; }
  else { print "blub konnte nicht gefunden werden!\n"; }

Dieser Code funktioniert jedoch nur, wenn Ihre Daten in der Variable $_ ( die wir übrigens auch mit dem strict- Pragma nie Deklarieren müssen) aufgeführt sind. Um das ganze mit einer benutzerdefinierten, deklarierten Variable durchzuführen müssen wir zu anderen Mitteln greifen:

#!/usr/bin/perl
use strict;
use warnings;
 
print "Geben Sie Ihre Daten ein:\n";
my $eingabe = <STDIN>;
 
if($eingabe =~ /blub/) { 
  print "blub wurde gefunden\n" } 
else { 
  print "blub wurde nicht gefunden\n" }

Wenn wir jetzt bei unserer Suche keine Rücksicht auf die Groß- und Kleinschreibung nehmen wollen, können wir dem Suchbegriff noch die Option i ("case-insensitive") hinzufügen:

if($eingabe =~ /blub/i) {

4.13 Objektorientierte Programmierung (OOP)

4.14 Nützliche Module

Module erleichtern das Schreiben von Programmen unter Perl wesentlich, jedoch sollte man dabei immer im Hinterkopf behalten, dass jedes Modul das Programm zusätzlich belastet.

Nachfolgend werden einige nützliche Module vorgestellt, dabei wird jedoch nur ein sehr kleiner Teil Ihrer vollen Funktion erwähnt, für weitere Informationen können Sie dem Link am Ende des jeweiligen Abschnittes folgen.

4.14.1 Getopt::Long

Das Modul Getopt::Long vereinfacht das Abfragen von übergebenen Parametern, an Ihr Programm. Ein vom Benutzer übergebener Parameter lässt sich folgendermaßen abrufen:

#!/usr/bin/perl
# getopt.pl -- by Ubuntu-Forum
 
use strict;
use warnings;
 
use Getopt::Long;
 
GetOptions( 'name=s'    => \my $name);
 
print "Hallo $name, wie geht es dir?\n";

In diesem Beispielprogramm wird der Parameter name abgefragt. Sollte der Benutzer das Programm mithilfe folgender Zeile im Terminal aufrufen, so würden der Benutzer mit: Hallo Otto, wie geht es dir? begrüßt werden

./getopt.pl -name Otto