12.1. Standardvariablen - $\, $/, $", $,, $., $             

Bevor Sie jetzt lernen, wie Sie einen Datei öffnen können, um aus dieser zu lesen bzw. zu schreiben, müssen Sie noch ein paar Standardvariablen kennenlernen.

Hierzu ein kurzes Skript das Sie in den nächsten Beispielen weiterverwenden werden ...

#!/usr/bin/perl -w

while(<>){
 print $_;
}

Den Eingabeoperator <> kennen Sie ja bereits. Meist haben Sie diesen in folgender Form verwendet ...

$eingabe = <STDIN>;

Da der Filehandle STDIN die default-Einstellung des Eingabe-Operators ist, können Sie diesen auch weglassen. Außerdem wissen Sie ja bereits, falls keine Variable angegeben wird, wie Beispielsweise mit ...

while(<>)

... dann wird automatisch in die Standardvariable $_ geschrieben. Daher können Sie sich auch diese Schreibweise ersparen ...

while ($_ = <>)

Wenn Sie das Programm bereits getestet haben, wissen Sie, dass dieses nichts anderes macht, als zeilenweise den Text von der Standardausgabe einzulesen und diesen Text anschließend mit print ausgibt.

Wenn Sie wollen, können Sie eine beliebige Textdatei mit diesem Programm auslesen, in dem Sie die Textdatei als 2. Argument hinter dem Programmnamen aufrufen ...

/usr/bin/perl -w programm.pl textdatei.txt

Unschön daran ist allerdings, dass der ganze Text auf einmal ausgegeben wird. Wenn Sie den Text zeilenweise ausgeben wollen müssen Sie das Programm ein wenig umschreiben ...

#!/usr/bin/perl -w

while(<>){
 print $_;
 <STDIN>;
}

Mit <STDIN>, Sie hätten auch <> schreiben können, wird die Textdatei jetzt Zeilenweise ausgegeben. Sie müssen allerdings nach jeder Zeile die Taste Enter drücken.

Nun ist es in Perl möglich mit Hilfe einer weiteren Standardvariablen ein eigenes Zeilentrennzeichen zu definieren. Zum Beispiel ...

#!/usr/bin/perl -w

$/ = "#";
while(<>){
 print $_;
}

Mit Hilfe der Angabe ...

$/ = "#";

... können Sie solange einen Text in der Standardeingabe eingeben, bis das Zeichen '#' gelesen wird. Erst danach wird der Text auf dem Bildschirm ausgegeben. Dies macht allerdings nur dann Sinn, wenn Sie Zeilen aus Dateien einlesen. Über die Standardeingabe machen Sie damit die Ausgabe nur Umständlicher.

Was in Perl etwas lästig sein kann ist, dass bei der print-Ausgabe jedes Mal für den Zeilenumbruch ('\n') zu sorgen ist. Dies nimmt uns Perl mit der Standardvariabel $\ ab. Mit dieser Standardvariablen legen wir den Abschluss einer Ausgabe fest ...

#!/usr/bin/perl -w

$\="\n";
print "Eine Demonstration zum Abschluss einer Ausgabe";
print "Diese Zeile ist nächste Zeile";

Durch die Angabe von $\="\n" werden alle Nachfolgenden Ausgaben mit einem Zeilenumbruch beendet.

Weitere Standardvariablen wären sogenannte Elementetrenner für Arrays. Dabei gibt es zwei Varianten. Zum einen die Standardvariable $, und $". Sie wissen ja wenn wir ein Array folgendermaßen ausgeben ...

#!/usr/bin/perl -w

$\="\n";

@array = ("Haus", "Auto", "Schiff", "Geld");
print @array;

... werden diese in einem Strang ohne Leerzeichen ausgegeben, es sei denn, man stellt Sie zwischen doppelte Hochkommata. Falls andere Zeichen als Hochkommata zur Ausgabe von Arrays erwünscht sind, gibt es die Standardvariable $, womit Sie das Trennzeichen für Arrays oder Hashes festlegen und womit Sie die einzelnen Wörter ohne den Anführungszeichen ausgeben ...

#!/usr/bin/perl -w

$\ = "\n";
$, = " * ";

@array = ("Haus", "Auto", "Schiff", "Geld");
print @array;

Mit der Standardvariable $" machen wir das selbe, nur das Sie hier die Ausgabe des Array in doppelten Hochkommas stellen ...

#!/usr/bin/perl -w

$\ = "\n";
$" = " * ";

@array = ( "Haus", "Auto", "Schiff", "Geld");
print "@array";

Mit der Standardvariablen $. können Sie die einzelnen Zeilennummern ausgeben ...

#!/usr/bin/perl -w

while(<>){
 print $. , ".Zeile : " , $_;
 }

Zu guter Letzt wäre da noch die Standardvariable $| zur Deaktivierung des Puffers. Die Pufferung der Ausgabe bewirkt, dass die Ausgabe aus STDOUT erst dann erfolgt, wenn ein Newline-Zeichen gelesen wird. Um dies zu deaktivieren genügt es der Standardvariable $| den Wert 1 zu übergeben.

Zusammenfassung der bisher vorgestellten Variablen  ...

• $/ Eigenes Zeilentrennzeichen
• $\ Abschluss einer Ausgabe
• $, $" Elemententrenner für Arrays
• $. Zeilennummerierung
• $| Pufferung

12.2. Reservierte Pattern-Matching-Variablen              

Es gibt noch einige nützlich reservierte Variablen für das Pattern-Matching (Mehr dazu folgt noch ... ). Hierzu erst mal ein Überblick ...

• $n - ⁿter geklammerter regulärer Ausdruck
• $& - Zuletzt verwendeter gematchter Ausdruck
• $` - Zeigt an was vor dem gematchtend Ausdruck steht
• $' - Zeigt an was hinter dem gematchten Ausdruck steht
• $+ - Zuletzt gematchte Klammer

Ein Beispiel noch, wie Sie diese reservierten Variablen verwenden können ...

#!/usr/bin/perl -w

use strict;

print "Bitte geben Sie einen Text ein : ";
chomp(my $text=<STDIN>);
print "Wonach wollen Sie im Text suchen : ";
chomp(my $suche=<STDIN>);

undef $/;

if($text=~m/$suche/){
    print "$suche gefunden!\n";
    }

print $& . " (zuletzt gematchter Ausdruck)\n" if defined $&;
print $` . " (steht vor dem gematchten Ausdruck\n" if defined $`;
print $' . " (steht hinter dem gematchten Ausdruck\n" if defined $';

Sie geben Beispielsweise als Text ein ...

Dies ist der Text der gematcht werden soll

... und als Suchbegriff ...

Text

Die Ausgabe sieht dann wie folgt aus ...

Text (zuletzt gematchter Ausdruck)
Dies ist der  (steht vor dem gematchten Ausdruck)
der gematcht werden soll (steht hinter dem gematchten Ausdruck)

12.3. Reservierte Variablen für Benutzer und Prozess-ID's              

Auch hierfür gibt es in Perl eindeutig definierte Variablen. Eine Prozess-ID ist eine eindeutige Zahl in der Prozesstabelle. Geben Sie einfach in einem Xterm den Befehl ps oder ps x ein und Sie bekommen alle laufende, schlafende oder tote Prozesse aufgelistet. PID entspricht dabei die Prozess-ID. Ein Prozess ist ein Programm während seiner Ausführung.

User und Gruppen-ID dienen zur eindeutigen Idenfizierung eines Users innerhalb des Systems und den Zugriffsrechten auf das System. Hierzu nun die reservierten Variablen für Benutzer-und-Prozess-ID ...

• $$ - Prozess-ID
• $< - Reale User-ID
• $> - Effektive User-ID
• $( - Reale Gruppen-ID
• $) - Effektive Gruppen-ID

Auch hierzu ein kleines Anwendungsbeispiel ...

#!/usr/bin/perl -w

print "Die aktulle Prozess-ID für $0 lautet $$\n";
print "Reale USER-ID : $< Effektive USER-ID : $>\n";

Sie können die ID's gerne in einer Shell mit dem Kommando id überprüfen. Die reserviert Variable $0 lernen Sie noch kennen. Diese gibt seinen eigenen Programmnamen aus.

12.4. Kommandozeilenargumente @ARGV              

Sie haben die Kommandozeilenargumente schon einmal verwendet ...

#!/usr/bin/perl -w

$counter=0;

while(@ARGV){
    print "argument[$counter] " , shift, "\n";
    $counter++
    };

Bei dieser Methode, die Kommandozeilenargumente zu durchlaufen, wurde bereits erwähnt, dass mit Hilfe von shift, @ARGV entleert (zerstrört) wird und somit nicht mehr für weiter Auswertungen zur Verfügung steht.

Bei Ausführung dieses Programms wird mancher C-Programmierer denken, diese Ausgabe ist doch  falsch. Beispielsweise Sie machen folgende eingabe ...

/usr/bin/perl -w programm.pl hallo hallo2

Die Ausgabe lautet dabei ...

argument[0] hallo
argument[1] hallo2

In C haben Sie gelernt, dass argv[0] für den Programmnamen steht. Nun in Perl ist dies nicht so. In Perl steht argv[0] für das was in C argv[1] ist usw. Um den Programmnamen in Perl zu erfahren, gibt es die reservierte Variable ...

$0 - Programmname

Angewandt auf das Skript sieht dies wie folgt aus ...

#!/usr/bin/perl -w

$counter=0;

print "Programmname $0\n";
while(@ARGV){
    print "argument[$counter] " , shift, "\n";
    $counter++;
    };

Um die einzelnen Argumente zu durchzulaufen, ohne @ARGV durch shift zu zerstören, verwenden Sie am besten eine foreach-Schleife ...

#!/usr/bin/perl -w

$counter=0;

print "Programmname $0\n";
foreach(@ARGV){
    print "argument[$counter] $_ \n";
    $counter++;
    }

Natürlich können Sie auch auf die einzelnen Argumente mit Hilfe des Indexes zugreifen ...

#!/usr/bin/perl -w

print "Programmname $0\n";
print "argument[0] " , $ARGV[0] , "\n" if defined $ARGV[0];
print "argument[1] " , $ARGV[1] , "\n" if defined $ARGV[1];
print "argument[2] " , $ARGV[2] , "\n" if defined $ARGV[2];

#usw.

12.5. Reservierte Variablen für Fehler             

Selbst für Fehlerbehandlungen gibt es in Perl reservierte Variablen ...

• $? - Fehlerstatus des system()-Aufrufs
• $! - Numerische Fehlerkontex errno
• $@ - eval()-Fehler (wurde bereits im Kapitel eval durchgenommen)

Sehen Sie sich folgendes Beispiel dazu an ...

#!/usr/bin/perl -w

$system1="lds -l";

system($system1);
print $? , "\n"; #-1
print $! , "\n"; #Datei oder Verzeichnis nicht gefunden

$!=0;

system("echo Hallo Welt");
print $? , "\n"; #0
print $! , "\n"; #keine Ausgabe

Mit der reservierten Variablen $? geben Sie den Rückgabestatus von einem system-Aufruf zurück. Und dieser ist wie in C bei Erfolg 0 und bei einem Fehler -1. Es wird hier auch auf die C-Funktion zurückgegriffen.

Die Variable $! gibt den Fehlercode zurück der in errno steht. Mehr dazu können Sie unter man errno nachlesen. Auch hier gilt wie in C, errno nach jeder Verwendung wieder auf 0 zurückzusetzen, da sonst der alte Wert in errno stehen bleiben könnte, obwohl kein Fehler aufgetreten ist.