<< Schleifen Inhalt Strings und Zahlen >>
Die Defaultvariable $_  |  Paramterübergabe bei Funktionen @_  |  Paramterübergabe beim Programmaufruf @ARGV  |  Das letzte Element im Array $#  |  Die Speichervariablen $1 und \1  |  Die Vergleichsvariablen $`, $& und $'  |  Die Fehlervariable $!  |  Die Variable zur Eingabentrennung $/

Spezielle VariablenPerl

SeitenanfangSeitenendeDie Defaultvariable $_

Diese Variable kennen wir schon ... Wir wissen auch, dass man die Variable $_ gar nicht sieht, wenn man diese verwendet. Hier noch einmal eine kleine unvollständige Liste, wo $_ auftritt:

Beispiel Beschreibung
print; Ausgabe auf die Standardausgabe (dasselbe wie print $_;)
foreach (@array) { statt foreach $_ (@array) bzw. foreach $eineVariable (@array)
/.../; statt $_=~/.../;
s/.../.../; statt $_=~s/.../.../;
chop($var); statt $_=chop($var);. Das abgeschnittene Zeichen in $var steht in $_. Liefert eine Funktion eine Rückgabe (wie z. B. chop()) und wird dieser Rückgabewert keiner Variablen zugewiesen, dann steht dieser in $_.

SeitenanfangSeitenendeParamterübergabe bei Funktionen @_

Auch diese Variable kennen wir schon: Das ist das Array in dem die Übergabeparameter einer Funktion stehen. @_ ist lokal! Aber das ist sowieso klar - zumindest geht man davon aus. Mit $_[0], $_[1], etc. greift man auf die Elemente von @_ zu. Man kann auch mit dem Ooperator shift das erste Element von @_ auslesen (in eine lokale Variable: my $file=shift(@_);) und löschen (vgl. Hinzufügen und Löschen von Arrayelementen). Innerhalb einer Funktion sind folgende Zeilen äquivalent:

sub irgendwas{
  my $variable=shift @_;
}

sub irgendwas{
  my $variable=shift;
}

shift bezieht sich innerhalb einer Funktion immer auf @_.

SeitenanfangSeitenendeParamterübergabe beim Programmaufruf @ARGV

Auch diese kennen wir schon: @ARGV enthält die Elemente die beim Programmaufruf übergeben wurden. Auch dieses Array kann - falls nötig - verändert werden. Wird der shift-Operator im Hauptprogramm (also in keiner Funktion) angewendet, so betrifft das das Array @ARGV.

SeitenanfangSeitenendeDas letzte Element im Array $#

Das $# wird in Zusammenhang mit einem Array gebraucht - und zwar mit dem letzten Element! Um genauer zu sein $#einArray ist der Index des letzten Elements. Man kann diesen Index abfragen und auch verändern:

@zahlen=10..20;

for ($i=0; $i<=$#zahlen; $i++){
  print $zahlen[$i]." ";
}

print "\n";

$#zahlen=5; # zuweisen der Laenge eines Arrays auf 6
for ($i=0; $i<=$#zahlen; $i++){
  print $zahlen[$i]." ";
}
C:\>perl zahlen.pl
10 11 12 13 14 15 16 17 18 19 20
10 11 12 13 14 15
C:\>

SeitenanfangSeitenendeDie Speichervariablen $1 und \1

Kennen wir auch schon (vgl. Klammerung und die Variable $1 bzw. \1 bei regulären Ausdrücken).

SeitenanfangSeitenendeDie Vergleichsvariablen $`, $& und $'

Zusätzlich zu $1 (...) besitzt Perl noch drei weitere Variablen $`, $& und $'. Diese beziehen sich auf den String, der mit dem Muster verglichen wird: $& verweist auf den Teil der Zeichenkette des getesteten Strings, auf dem das ganze Muster passt. $` den Teil verweist auf den String vor dem Muster und $' auf den Teil nach dem Muster. Diese Variablen werden auch Vergleichsvariablen genannt.

$zahlen="123456789";

print 'Zahlen : '.$zahlen."\n\n";

$zahlen=~/4(.).(.)/;

print 'Klammer: '.$1."\n";
print 'Muster : '.$&."\n";
print 'vorher : '.$`."\n";
print 'nachher: '.$'."\n";

Das ergibt:

C:\>perl muster.pl
Zahlen : 123456789

Klammer: 5
Muster : 4567
vorher : 123
nachher: 89

C:\>

SeitenanfangSeitenendeDie Fehlervariable $!

Wird ein Systemfehler erzeugt, so gibt $! den Fehler an: Entweder die Nummer des Fehlers - falls $! in einem numerischen Kontext steht - oder den Fehlertext - falls $! in einem Zeichenkettenkontext steht:

open FILE, "X";

print "Errortext: $!\n";
print "Errornumber: ".(0+$!)."\n";

close FILE;

Ergibt:

C:\>perl errorTest.pl
Errortext: No such file or directory
Errornumber: 2

C:\>

SeitenanfangSeitenendeDie Variable zur Eingabentrennung $/

Normalerweise ist das Standardtrennzeichen zur Eingabetrennung das Newlinezeichen "\n". Liest man dann ein File ein (z. B. mit einer while-Schleife) geschieht dies zeilenweise, weil das Trennzeichen eben das Newlinezeichen ist. Wird dies verändert - z. B. auf undef - das ist ein undefinierter Wert (nicht 0 oder "") - dann kann man das einlesen noch schneller gestalten. Um das Trennzeichen zu ändern muss die Variable $/ neu gesetzt werden. Das ist aber mit Vorsicht zu geniesen. In jedem Fall sollte dies nur lokal (das heißt mit local) passieren und nicht global!

Einlesen - mal etwas anders:

my $fn;
chomp($fn=<STDIN>);

print readFile($fn);

###
sub readFile(){
  local $/=undef; # setzte $/ auf undef
  my $inhalt="";

  open(FH,$_[0]);
  $inhalt=<FH>;
  close(FH);

  $inhalt;
}

Ein Beispielprogramm um den Abbruch der Standardeingabe zu verändern: Von "\n" nach "\nquit\n".

local $/="\nquit\n"; # Standard: $/="\n";

$x=<stdin>;

print "$x\n";

myChomp($x);
print "$x\n";

###
sub myChomp{
  my $_nl=$/;
  if ($_[0]=~s/$_nl$//) { # $_[0] ist eine Referenz auf $x
    $_nl;
  }
  else { ""; }
}
Bemerkung: Statt myChomp() kann man auch die Perlfunktion chomp() verwenden. Diese bezieht sich automatisch auf die Variable $/.

Die Defaultvariable $_  |  Paramterübergabe bei Funktionen @_  |  Paramterübergabe beim Programmaufruf @ARGV  |  Das letzte Element im Array $#  |  Die Speichervariablen $1 und \1  |  Die Vergleichsvariablen $`, $& und $'  |  Die Fehlervariable $!  |  Die Variable zur Eingabentrennung $/
<< Schleifen Inhalt Strings und Zahlen >>
Seitenanfang FehlermeldungHilfe zur Fehlermeldung © 2001-2003 Email an den AutorPerl, Lehrstuhl Mathe II, Uni Bayreuth