Zur Homepage www.HI-Tier.de Schnellübersicht Perl
Zurück Home Nach oben Weiter
Öffentlicher Bereich für Entwickler

 

Perl - kurz und bündig

bulletKontrollstrukturen
bulletZahlen: Literale, Operatoren und Funktionen
bulletZeichenketten: Literale, Operatoren und Funktionen
bulletListen und Arrays: Literale, Operatoren und Funktionen
bulletHashes: Literale, Operatoren und Funktionen
bulletDateizugriffe
bulletreguläre Ausdrücke
bulletSocketverbindungen
bulletFunktionen
bulletNützliche Beispiele

horizontal rule

Kontrollstrukturen

bulletKommentare
werden mit # eingleitet und gehen bis zum Ende der Zeile
bulletAnweisungsblöcke
sind in {} eingeschlossen und enthalten eine Folge von Anweisungen
bulletif() {} else {}
Bedingte Abfrage,
kann umgedreht werden:
$a=4 if ($b=0);
zu lesen als: a=4 wenn b=0
bulletunless() {}
Wenn-Nicht-Abfrage
bulletif() {} elsif() {} else {}
erweitertes if(): mehrere bedingte Abfragen
bulletwhile() {}
wiederholt Anweisungsblock solange, bis die Bedingung nicht mehr stimmt
bulletuntil() {}
wiederholt Anweisungsblock solange, bis die Bedingung stimmt
bulletdo {} while()
do {} until()

analog while() bzw. until(), nur daß hier der Anweisungsblock in jedem Fall mindestens einmal ausgeführt wird
bulletfor() {}
initialisiert einen Ausdruck, testet ihn, führt den Anweisungsblock aus und verändert den Ausdruck. Anschließend wird solange getestet, der Anweisungsblock ausgeführt und der Ausdruck verändert, bis der Test fehlschlägt,
for($i=0; $i<scalar(@array); ++$i) {...}
bulletforeach $var () {}
arbeitet eine Liste ab, weist jeweils $var den Wert zu und führt damit den Anweisungsblock aus. Statt $var kann $_ verwendet werden,
foreach $datei (@dateiliste) {...}
foreach $key (keys %hash) {...}
bulletFunktionsaufrufe müssen nicht zwingend mit Klammern geschrieben werden. Funktionen, die eine Liste als Parameter erwarten, müssen eine Liste (sprich (elem1,elem2,...)) übergeben, zu der -wie das Listenkonstrukt vorschreibt- runde Klammern gesetzt werden müssen.
Alle anderen können ohne runde Klammern auskommen, es sei denn, die Funktion kommt generell nicht mit Listen klar, sondern nur mit einem Skalar oder keinem Übergabewert.
Die Klammersetzung ist unabhängig vom Rückgabewert.

push(@array,'neuesElement');
ist gleich
push @array,'neuesElement';
Falsch wäre z.B.
@schluesselliste = keys(%hash1,%hash2);
Richtig dagegen:
@schluesselliste = keys(%hash1);
@schluesselliste = keys %hash1;
Ebenso kann die aktuelle UNIX-Zeit wie folgt ermittelt werden:
$now = time;
$now = time();

horizontal rule

Zahlen: Literale, Operatoren und Funktionen

Literale
bulletVariable: $var
bulletGanzzahlen
bulletFließkommazahlen, auch in wissenschaftlicher Form

Intern wird grundsätzlich mit Fließkomma gerechnet

Operatoren
bulletZuweisen mit =
bulletGrundrechenarten: +, -, *, /
bulletPotenz ** und Modulo %
bulletVergleichsoperatoren: <, <=, ==, >=, >, !=
bulletbinäre Zuweisungen: +=, -=, *=, /=, **=, %=, .=
bulletAutoinkrement ++ und Autodekrement --
Funktionen  

horizontal rule

Zeichenketten: Literale, Operatoren und Funktionen

Literale
bulletVariable: $var
bulletZeichenketten in einfachen Anführungszeichen
in ihr werden keinerlei Ersetzungen durch \-Codes durchgeführt, es gelten jedoch 2 Ausnahmen: '\'' stellt das einfache Anführungszeichen dar, ohne daß es die Zeichenkette beendet und '\\' stellt den Backslash dar
bulletZeichenketten in doppelten Anführungszeichen
in diesen Zeichenketten sind ähnliche \-Codes wie die von C erlaubt, wie z.B. "\n". Zudem werden Variablen jeder Art ersetzt (mit Ausnahmen)
Operatoren
bulletZuweisen mit =
bulletAneinanderketten von Zeichenketten mit . (Punkt)
bulletVergleichsoperatoren: lt, le, eq, ge, gt, ne (analog den Zahlen); in neueren Perl sind diese deprecated und durch die üblichen Vergleichsoperatoren ersetzt worden
bulletWiederholungsoperator x: Anzahl Wiederholungen der Zeichenkette,
z.B. "Haus" x 5 ergibt "HausHausHausHausHaus"
Funktionen
bulletchop(str)
schneidet das letzte Zeichen des Strings str ab
bulletchomp(str)
entfernt nur ein Newline (\n) als letztes Zeichen von str; ist keines dort, dann bleibt sie unverändert,
nützlich zum Einlesen von Zeilen aus Dateien:
while(<IN>) {
   chomp;
   # Variable $_ enthält nun Zeile ohne Newline
}

horizontal rule

Arrays bzw. Listen: Literale, Operatoren und Funktionen

Literale
bulletVariable: @var
bulletin runde Klammern eingeschlossene skalare Daten, die nicht zwingend vom selben Typ sein müssen,
@array = (1,4,9);
bulletAnlegen eines Arrays in Form einer Referenz über eckige Klammern:
$refToArray = [1,4,9];
Dann kann auf die Elemente mit dem Verweisoperator zugegriffen werden:
print $refToArray->[1];
oder durch Rückwandlung in ein Array:
print $$refToArray[1];
Funktionen, die keine Referenzen mögen, erhalten den nativen Datentypen durch Casten:
foreach $item (@$refToArray) {...}
Operatoren
bulletListenkonstruktor .., der eine Liste von Elementen zwischen den Anfangs- und Endwerten anlegt, die jeweils um den Wert 1 voneinander getrennt sind,
arbeitet nur mit ganzzahligen Indexen!
z.B. (1.2 .. 5.5) ergibt (1,2,3,4,5)
bulletZugriff auf einzelne Elemente mit $var[index]
bulletZugriff auf mehrere Elemente (genannt Slice) mit $var[index,...] oder über Listenoperator $var[start..ende]
bulletReferenzoperator $: Liefert eine Referenz auf ein Element. Zugriff auf einzelne Elemente mit $$var[index]
Funktionen
bulletpush(@var,$var,...)
$var,... am Ende der Liste @var anhängen
bulletpop(@var)
entfernt und liefert letztes Element der Liste
bulletshift(@var)
entfernt und liefert erstes Element der Liste
bulletunshift(@var,$var,...)
$var,... am Anfang der Liste @var anhängen
bulletreverse(@var)
dreht die Reihenfolge der Elemente in der Liste um
bulletsort(@var)
sortiert die Liste in der einfachsten Form als Zeichenketten, auch wenn es Zahlen sind
bulletchomp(@var)
entfernt nur ein Newline (\n) als letztes Zeichen von jedem Element in der Liste; ist jeweils keines dort, dann bleiben sie jeweils unverändert
bulletgrep(regexpr,@var)
filtert anhand eines regulären Ausdrucks aus einer Liste passende Elemente und liefert wieder eine Liste,
z.B. @filtered = grep(/^#/,@elements);
(liefert alle Elemente, beginnend mit '#')
bulletscalar(@var)
wandelt ein Array in ein Skalar um, indem es die Länge des Arrays zurückgibt. Bei
for($i=0; $i<@array; ++$i) {... $a=$array[$i]; ...}
erkennt Perl selbst, daß die Vergleichsbedingung nur ein Skalar sein kann und wendet von sich aus scalar() an. Sicherheitshalber sollte man das scalar() jedoch anwenden:
for($i=0; $i<scalar(@array); ++$i) {... $a=$array[$i]; ...}

Für SM-Programmierer :-):

bulletqw(words)
erzeugt eine Liste aus durch Leerzeichen getrennten Wörtern; die Wörter dürfen nicht in Anführungszeichen stehen

horizontal rule

Hashes: Literale, Operatoren und Funktionen
(Hash: ein Schlüssel-Wert-Paar)

Literale
bulletVariable: %var
bulletin runde Klammern eingeschlossene skalare Daten, die paarweise Schlüssel und Wert enthalten,
%hash = ('auto'=>'bmw','raeder'=>4);
bulletAnlegen eines Hashes in Form einer Referenz über geschweifte Klammern:
$refToHash = {'auto'=>'bmw','raeder'=>4};
Dann kann auf die Elemente mit dem Verweisoperator zugegriffen werden:
print $refToHash->{'auto'};
oder durch Rückwandlung in einen Hash:
print $$refToArray{'raeder'};
Funktionen, die keine Referenzen mögen, erhalten den nativen Datentypen durch Casten:
foreach $item (keys %$refToHash) {...}
Operatoren
bulletZugriff auf einzelne Elemente mit $var{key}
bulletZugriff auf mehrere Elemente (genannt Slice) mit @var{key,...}
bulletreverse %var
erzeugt neuen Hash, der die Werte als Schlüssel und die Schlüssel als Werte enthält. Achtung: Mehrere identische Werte werden zu einem(!) Schlüssel, hierbei ist nicht festgelegt, welcher letztendlich gesetzt wird.
Funktionen
bulletkeys()
erzeugt eine Liste aller Schlüssel
bulletvalues()
erzeugt eine Liste aller Werte in der Reihenfolge, wie sie bei keys() zurückgegeben würde
bulleteach()
liefert ein Schlüssel-Wert-Paar und erhöht intern einen Zählindex, so daß alle Hasheinträge abgearbeitet werden können. Die Reihenfolge der Einträge ist dabei nicht festgelegt.
bulletDie Länge eines Hashes ermittelt man leicht aus der Länge der vorhandenen Keyliste:
$laengeDesHash = scalar(keys(%hash));

horizontal rule

Dateizugriffe

Literale
bulletVariable in <> eingeschlossen
bulletZeileneingabeoperator <> (ohne Name darin) liest Daten aus den Dateien, die bei der Übergabe beim Start vom Programm angegeben werden
bullet<STDIN> liest von Standardeingabe
Operatoren
bulletZuweisungen:
bullet$var = <name> weist $var eine gelesene Zeile zu
bullet@var = <name> weist @var alle gelesenen Zeilen in Form einer Liste zu
bullet$_ enthält eine gelesene Zeile, wenn keine Variable angegeben wird
Funktionen
bulletopen(filehandle,file specifier)

Öffnet eine Datei. Der file specifier enthält neben dem Dateinamen vorangestellte Steuerzeichen, die den Modus der Datei anzeigen:

bulletohne Steuerzeichen wird die Datei zum Lesen geöffnet
bulletmit vorangestelltem '>' wird die Datei zum Schreiben geöffnet
bulletmit vorangestelltem '>>' wird die Datei zum Anhängen geöffnet
bulletmit vorangestelltem '|' wird eine benannte Pipe geöffnet

Die Funktion liefert undef, sollte die Datei mit dem gewünschten Modus nicht geöffnet werden können

bulletclose(filehandle)

schießt eine zuvor mit open() geöffnete Datei

bulletprint filehandle string

gibt eine Zeichenkette über den Filehandle aus. Zu beachten ist, daß zwischen Filehandle und Zeichenkette kein Komma stehen darf. Wird Filehandle weggelassen, dann nimmt Perl das immer geöffnete Filehandle STDOUT an.

Wichtig: Die Funktion write dient nicht der Ausgabe von Daten in eine Datei!

bulletread filehandle, scalar, length [, offset]

liest die gegebene Anzahl Bytes aus der Datei mit dem Filehandle in die skalare Zeichenkette.  Der Offset zeigt nur die Position an, an der die gelesene Zeichenkette im Skalar eingefügt wird.

Verzeichnisse Verzeichnisse können auch ausgelesen werden:
bulletopendir(dirhandle,directoryname)

Öffnet ein Verzeichnis, um die darin befindlichen Dateien verarbeiten zu können

bulletclosedir(dirhandle)

schließt ein zuvor mit opendir() geöffnetes Verzeichnis

bulletreaddir(dirhandle)

liest im Listenkontext alle im geöffneten Verzeichnis befindlichen Dateien ein (einschließlich '.' und '..') und im Skalarkontext den nächsten Verzeichniseintrag

horizontal rule

Reguläre Ausdrücke

Format
bulletOperator/Ausdruck/Optionen
bulletOperator/Ausdruck/Ersetzungsteil/Optionen

Wirkt grundsätzlich auf die Variable $_.

Operator Operatoren legen fest, was der reguläre Ausdruck bewirken soll:
s Erzetze gefundenes Muster mit Zeichenkette
m Vergleiche Muster mit Zeichenkette; der Operator kann weggelassen werden. Er ist jedoch nötig, wenn das Begrenzungszeichen verändert werden muß (s.u.)
Ausdruck Im Ausdruck ist zulässig:
bulletEin Zeichen, das an der gegebenen Stelle erwartet wird
bulletEin . (Punkt), der auf alle Zeichen außer Newline paßt
bulletMuster für mehrere passende Zeichen an einer Stelle in []; hierbei sind Zeichenbereiche (z.B. 0-9) möglich. Soll das Zeichen '-' oder '\'dargestellt werden, dann wird jeweils ein '\' vorangestellt, z.B. [0-9\-]
bulletFür Muster für mehrere nicht passende Zeichen gilt gleiches wie bei [], nur daß vor alle Zeichen ein ^ gesetzt wird, z.B. [^0-9\-]
bulletMultiplikator *: null- oder mehrmals das unmittelbar vorhergehende Zeichen bzw Zeichenklasse
bulletMultiplikator +: ein- oder mehrmals das unmittelbar vorhergehende Zeichen bzw Zeichenklasse
bulletallgemeiner Multiplikator {s,e}: mindestens s mal und höchstens e mal das unmittelbar vorhergehende Zeichen bzw Zeichenklasse
bulletKlammern () als Zwischenspeicher: der in der Klammer eingeschlossene Ausdruck wird für weitere Verwendung gespeichert und kann mit \n (mit n = 1, 2, ..) wiederholt werden, z.B. ist der Wert in Klammern bei fred(.)barney\1 ein X, dann wird bei \1 auch ein X erwartet.
bulletAuswahlen werden mit | angeboten, es muß dann eines der angegebenen passen. Bei mehreren Zeichen müssen die Auswahlen in () gesetzt sein.
bulletAnkermuster legen bestimmte Positionen fest, z.B. Wortgrenzen \w, Satzanfang ^, Satzende $.
Ersetzungsteil Je nach Operator dient sie einem bestimmten Zweck:
bulletOperator s
bulletOption e
bulletErsetzungsteil stellt einen Perl-Code dar, der ausgeführt wird und eine Zeichenkette liefert. Dies kann auch eine selbst zusammengestellte Zeichenkette sein, wobei man die Anführungszeichen für die Zeichenkette nicht vergessen darf
bulletsonstige Optionen
bulletErzetze gefundenes Muster mit dieser Zeichenkette
bulletOperator m
bulleter hat keinen Ersetzungsteil, da der Operator m nur vergleicht und keine Aktion auf das gefundene Muster ausführt
Optionen Je nach Operator dient sie einem bestimmten Zweck:
i Groß-/Kleinschreibung ignorieren
g alle Auftreten des regulären Ausdrucks betrachten, sonst nur das erste
m betrachte Zeichenkette als eine Zeile, auch wenn '\n' enthalten sind
s betrachte '\n' nicht als Zeilenende
e führe den Ersetzungsteil als Programmcode aus, statt ihn nur zu ersetzen
Anmerkungen
bulletÄndern des Begrenzungszeichens
mit z.B. m#^/usr/local/bin# läßt sich das # statt dem / als Begrenzungszeichen verwenden. Wichtig dabei ist, daß der Operator m vorangestellt wird!
bulletAuswählen eines anderen Ziels (der =~-Operator)
Statt $_ läßt sich jede beliebige Variable verändern:
$var =~ <regulärer Ausdruck>
bulletVariableninterpolation
Eine Variable in einem regulären Ausdruck wird erst aufgelöst und dann zum Mustervergleich herangezogen,z.B.:
$var="Vogel";
if ($text =~ /\b$var\b/) { ... }

liefert aufgelöst
if ($text =~ /\bVogel\b/) { ... }
Soll das $ selbst Teil des Strings sein, einfach escapen zu \$.
bulletBesondere nicht-beschreibbare Variablen
bullet$1, $2,... enthalten die Werte von \1, \2, ...
bullet$& enthält Teil der Zeichenkette, die zum regulären Ausdruck paßt
bullet$` enthält Teil der Zeichenkette vor $&
bullet$´ enthält Teil der Zeichenkette nach $&
Funtionen
bulletsplit(regExpr,$var)
teilt $var in Teile auf, deren Trennzeichen bzw. Trenntexte auf den regulären Ausdruck passen, z.B.:
split(/\+/,"Ich+bin+ein+Beispiel")
teilt die Zeichenkette in die Wörter Ich, bin, ein und Beispiel auf.
bulletjoin($var,@var)
fügt eine Liste @var von Elementen mit jeweils einem Text $var zusammen zu eine Zeichenkette,
$erg = join("+",('Ich','bin','gut!'));
liefert Ich+bin+gut!

horizontal rule

Socketverbindungen

Notwendig Um mit Socketverbindungen arbeiten zu können, muß das Package Socket vor der ersten Anwendung eingebunden werden:

use Socket;

Verbindungsaufbau Der Ablauf gliedert sich in drei Schritte:
  1. Überprüfung, ob die Ziel-Adresse überhaupt bekannt ist, indem die Adresse per DNS aufgelöst wird:

    $iaddr =  inet_aton($address)

    inet_aton() liefert eine 4 Bytes lange Zeichenkette mit der zeichencodierten IP-Adresse,
    $iaddr = inet_aton('hitserver.hi-tier.de');

  2. Öffnen des Socket und sichern in einem Handle:

    socket(SOCKETHANDLE,PF_INET,SOCK_STREAM,getprotobyname('tcp'))

    Liefert undef, sollte der eigene Socket nicht geöffnet werden können.

    Mit den Parametern wird eine Internet-Verbindung und ein Stream über das Protokoll TCP initialisiert. Andere Parameter wären z.B. mit UDP-Protokoll.

  3. Nach offenem Socket läßt sich nun eine Verbindung zwischen dem eigenen Socket und dem Port am Zielrechner öffnen:

    connect(SOCKETHANDLE,sockaddr_in($port,$iaddr))

    sockaddr_in($port,$iaddr) packt die Portnummer und die IP-Adresse in ein internes Format für den Funktionsaufruf in connect(). Mit dem Handle für die Socketverbindung wird nun anhand der Zieladresse die Verbindung aufgebaut.

Verbingungsabbau Es genügt, wenn der Socket-Handle geschlossen wird:

close SOCKETHANDLE

Den Rest erledigt Perl wegen seiner objekt-orientierten Pakete selbst.

Funktionen
bullet$ipaddr = join('.',unpack("CCCC",$iaddr))

Um die gepackte Form der IP-Adresse (von inet_aton()) in der korrekten und leserlichen Form weiterverwenden zu können, wird diese damit als numerische IP aufbereitet.

horizontal rule

Funktionen

bulletEigene Funktionen werden mit sub {} definiert,
sub vergleich {
   return ($anzahlRaeder<4);
}
bulletEs gibt in Perl keine Parameterlisten beim Funktionsnamen. Die Parameter werden innerhalb einer Funktion als Array @_ bereitgestellt. Die können entweder als ganzes einzelnen Variablen zugewiesen werden:
sub funktion {
   my ($param1,$param2,$param3) = @_;
   ...
}
oder mit dem shift-Operator der Reihe nach:
sub funktion {
   my $param1 = shift;
   my $param2 = shift;
   my $param3 = shift;
   my $param4 = shift(@_);   # ohne @_ wäre es identisch
   ...
}
Da die internen Variablen $_ und @_ defaultmäßig für Funktionsaufrufe verwendet werden, sollten keine angegeben sein, kann man bei shift das @_ weglassen.
bulletLokale Variablen in Funktionen kennt Perl von Haus aus nicht. Generell sind alle Variablen (innerhalb eines Package) global. Es gibt zwei Konstrukte, lokale Variablen zu definieren, die um umgebenen Hauptprogramm nicht einsehbar sind:
my $frischeVariable = 4711;
oder
local $lokaleBezeichnung = "08-15";
my legt echte lokale Variablen an, die nur innerhalb eines Blocks {...} gültig sind und auf die auch nur innerhalb diesem zugegriffen werden kann. local selbst repräsentiert lediglich einen Wert (legt somit keine neue Variable an) innerhalb eines Blocks {...} und in von darin aufgerufenen Unterprogrammen. Seitens der perl-Entwickler wird jedoch grundsätzlich empfohlen, my zu verwenden.
bulletRückgabewerte werden mit return angegeben. Gibt es kein return, wird das Ergebnis des zuletzt ausgeführten Ausdrucks zurückgegeben.
bulletDer Aufruf einer Funktion aus einem Package oder einer anderen oder gar selben Funktion heraus, entspricht dem Verfahren anderer Sprachen:
$erg = meineFunktionVergleicht(1,2);
oder besser mit Prefix &:
$erg = &meineFunktionVergleicht(1,2);
& liefert nicht die Referenz oder Zeiger auf ein Element!

 

horizontal rule

Nützliche Beispiele

Programmabbruch

Zum Abbrechen des Programms wegen eines schweren Fehlers gibt es die Funktion die(). Diese erwartet einen String, der als Fehlermeldung ausgegeben wird, bevor sich das Programm gnadenlos beendet.

Wichtig hierbei ist das letzte Zeichen des Strings: Steht am Ende des String ein Newline '\n', werden Zeilennummern samt Perl-Fehlertext nicht ausgegeben. Fehlt es, dann erscheint erst die eigene Fehlermeldung und daran angehängt ein Text der Art at ___ line __.

Daneben gibt es auch den normalen exit()-Aufruf, der jedoch nichts weiter ausgibt (setzt nur einen numerischen Rückgabewert, wenn angegeben).

Zeilenweises Einlesen aus einer Datei

open(IN,"einzulesendeDatei.dat") or die "Öffnen fehlgeschlagen: $!\n";
while(<IN>) {
   chomp;       # Newline entfernen, $_ enthält nun die Zeile ohne Newline
   print $_;    # gib Zeile ohne Newline auf Screen aus
}
close(IN);

Filehandles sind einfache Literale ohne Kennzeichnung wie $ bei Arrays. Der erste Parameter des open()-Aufrufs legt eins an. Der <>-Operator liest einen "Record" ein. Standardmäßig liest er eine Zeile, kann aber über Flags geändert werden, daß er z.B. die ganze Datei am Stück einliest oder byteweise in Blöcken.

$! ist übrigens eine interne Statusvariable, die den letzten I/O-Error beinhaltet. Sollte open() fehlschlagen, steht dort warum.

EInlesen eines Verzeichnisses

Ähnlich dem Dateieinlesen gibt es eigene Methoden zum Einlesen von Verzeichnissen:

$verz = 'C:\temp'
opendir(DIR,$verz) or die "Verzeichnis nicht gefunden: $!\n";
@entries = readdir(DIR);
closedir(DIR);

Hiermit werden alle Einträge des Verzeichnisses in @entries eingelesen.

Analog dazu kann man auch einzeln Einträge lesen:

opendir(DIR,$verz) or die "Verzeichnis nicht gefunden: $!\n";
@entries=();
while ($entry=readdir(DIR)) {
   push @entries,$entry;
}
closedir(DIR);

@entries enthält auch die Einträge "." (aktuelles Verzeichnis) und ".." (übergeordnetes Verzeichnis). Um diese außen vor zu lassen, grep()t man sie weg:

@entries = grep(!/^\.{1,2}$/,@entries);

oder

@entries = grep(!/^(\.|\.\.)$/,@entries);

oder als Block {...}

@entries = grep { !/^(\.|\.\.)$/ } @entries;

(damit wird von rechts nach links jeweils ein Arrayelement durchgereicht und verarbeitet)
oder gleich beim Einlesen:

@entries = grep { !/^(\.|\.\.)$/ } readdir(DIR);

Da den @entries das Verzeichnis fehlt, kann man es sich (recht einfach gemacht) anhängen:

@entries = map { $verz."\\".$_ } grep { !/^(\.|\.\.)$/ } readdir(DIR);

Möchte man nur Dateien haben, muß grep() auf "Datei" prüfen:

@files = grep { -f $_ } map { $verz."\\".$_ } readdir(DIR);

Wichtig hierbei ist die Reihenfolge: Steht grep() nach map(), dann fehlt dem "-f" Operator die Verzeichnisinformation, um korrekt auf eine Datei zu prüfen. "." und ".." brauchen nicht geprüft werden, da diese Verzeichnisse sind und dabei sowieso rausfallen.

Die Art und Weise, komplette Dateipfadangaben zu erstellen, ist unsicher, daher gibt es das Package File::Spec::Functions mit nützlichen Funktionen:

use File::Spec::Functions;
$fullPath = catfile("C:","windows\fonts","tahoma.ttf");
$fullPath2 = catfile("/var/tmp","messages.log");

$fullPath ist dann "C:\windows\fonts\tahoma.ttf"
$fullPath2 ist dann "\var\tmp\messages.log"
(wenn unter Win32 angewandt)

Sortieren von numerischen Arrays

Ein Aufruf der Form

@sortierteZahlen = sort @unsortierteZahlen;

reicht nicht aus, um korrekt numerisch zu sortieren, da Perl von Haus aus generell Strings kennt (auch wenn sie für uns numerisch erscheinen). Das Array (10,2,1) würde dann als (1,10,2) sortiert.

sort() selbst kann jedoch eigene Vergleichsoperatoren und -funktionen anwenden. Um numerisch zu sortieren reicht dies:

@sortierteZahlen = sort { $a <=> $b } @unsortierteZahlen;

Der Operator <=> betrachtet seine beiden Operanden als Zahlen und vergleicht so. Der Aufruf

@sortierteZahlen = sort { $a cmp $b } @unsortierteZahlen;

ist demnach identisch mit

@sortierteZahlen = sort(@unsortierteZahlen);

Die Parameter $a und $b im sort{}-Block sind vorgegeben, damit sort() diese für den Vergleich belegen kann.

Als Funktion liese sich das so lösen:

sub numCompare {
   my $a=shift;
   my $b=shift;
   return $a - $b;
}
@sortierteZahlen = sort { &numCompare($a,$b); } @unsortierteZahlen;
@absteigendSortierteZahlen = sort { &numCompare($b,$a); } @unsortierteZahlen;

Um aufsteigend und absteigend zu ändern, vertauscht man lediglich die beiden Parameter $a und $b innerhalb des sort{}-Blocks.

Kommandozeilen-Argumente

Nach dem Programmstart sind im Array @ARGV die Kommandozeilenparameter zu finden. Dieses kann direkt mit Indexen $ARGV[0], ... oder mit shift verarbeitet werden. Bei shift ist zu beachten, daß shift bei wiederholtem Aufruf das Array jeweils um das erste Element erleichtert bis es leer ist.

Der Name des Programms selbst ist in $0 (Dollar Null :) zu finden.

 

20030805 Ralph Reuchlein

 

© 1999-2015 Bay.StMELF, verantwortlich für die Durchführung sind die Stellen der Länder , fachliche Leitung ZDB: Frau Dr. Kaja.Kokott@hi-tier.de, Technik: Helmut.Hartmann@hi-tier.de
Seite zuletzt bearbeitet: 01. Februar 2016 18:49, Anbieterinformation siehe hier im Impressum.