0 PERL - Ein 25-Minuten-Crashkurs!

;o)

0.1 Einleitung zum PERL-Crashkurs

Der vorliegende Text ist eine superkurzminimaleinführung/übersicht in PERL. Sie ist im Prinzip ein Konglomerat aus allen möglichen Notizen usw. welche ich selbst während des lernens der Sprache aus vielen Quellen zusammengeklaut habe. Im nachhinein hat es sich als 'Nachschlagewerk', welches während des Programmierens neben dem Rechner liegt, bewährt. Ohne Grundkenntnisse in der Programmierung und entsprechender Begriffe kann man hiermit nichts anfangen! Es ist keine Referenz und NICHT vollständig! Ich übernehme Haftung für rein gar nichts!

Für mich überraschend habe ich diese Anleitung in einigen Foren und 'Tutorial'-Sammlungen wiedergefunden. Ich werde deswegen hier und da kleine Verweise einfügen, welche im 'Original' von 1997 nicht vorhanden sind.

Carsten Bank im Oktober 2001

1 Die Sprache PERL

PERL = Practical Evaluation and Report Language
oder
PERL = Practical Extraction and Report Language???

interpretierte Sprache (Erfinder: Larry Wall)

GNU-Produkt, also kostenlos

auf fast allen Betriebssystem-Plattformen vorhanden - das macht es so interessant (Portabilität)

Perl-Skripte vergleichbar mit awk-, sed-, shell-Skripten und C-Programmen

Hauptanwendungen sind:

Manipulation von Textdateien

Extraktion von Texten

Texte formatieren

im Laufe der Weiterentwicklung:

Dateien und Prozesse manipulieren

Aufgaben im Netzwerkbereich

interessant für Systemverwalter, die unterschiedliche Systeme verwalten müssen

Diese Eigenschaften haben PERL im Zuge der Entwicklung des World Wide Web zu einer vielverwendeten Programmiersprache, z.B. für die Manipulation von HTML-Code, werden lassen.

2 PERL-Skripte

2.1 PERL in der Kommandozeile

Befehle können mittels Optionen auch in der Kommandozeile eingegeben werden:

Option -e: PERL-Befehl aus/in Kommandozeile ausführen

perl -e 'print "Hallo\n";'

Option -n: Alle Zeilen der Datei <datei> ausgeben

perl -ne 'print' <datei>

oder auch mit dem aus UN*X bekannten |:

date | perl -ne 'print "heute ist der $_"'

Die 'Umleitung' wird in $_ gespeichert!

Option -c: Syntaxprüfung PERL-Befehl/Datei ohne Ausführung

perl -c <datei>

Option -v: Versionsbestimmung des verwendeten Perl-Interpreters

perl -v

2.2 Skript-Aufbau

Am besten an einem Beispiel:

Anweisung:                Bedeutung:
===========================================================================
#!/usr/bin/perl           #! und absoluter Pfadname des PERL-Programmes

# Kommentaranweisung      beginnen mit Doppelkreuz und gehen bis zum Zeilen-
                          ende

print "Herzlich           PERL-Anweisungen (Werden mit ; abgeschlossen!)
willkommen\n";

$ Skriptname              Skript ausführen (An Zugriffsrechte denken!)

sub functname {		  evtl. Unterprogramme/Funktionen
 ...
}

3 Drucken

Immer wenn ein Programm (Perl-Skript) gestartet wird sind drei Dateien geöffnet, nämlich stdin, stdout und stderr. Perl erbt diese von der Shell in einem Dateihandle, es greift also nicht direkt darauf zu! Die Namen der Handles sind (zur verblüffung aller): STDIN, STDOUT und STDERR. Es können natürlich auch andere Dateihandles erzeugt werden.

3.1 Wörter

Jedes Wort, das nicht in Hochkommata steht, muß mit Alpha-Zeichen anfangen.

(Weitere Alpha-Zeichen und _ können folgen.)

Perl unterscheidet zwischen Klein- und Großbuchstaben

Hochkommata:

Zeichenketten in ' ' oder " "

'Zeichenkette': Jedes Zeichen wird als Literal behandelt.

"Zeichenkette": Variablenersetzung und Escape-Sequenzen werden gesondert behandelt.

Sonderzeichen (z.B. $, @, %) müssen "geflüchtet" (\) werden oder in ' ' stehen.

Literale = Konstanten:

numerische:

12345: ganze Zahl

0xff: hexadezimale Zahl

034: oktale Zahl

1.45: Gleitkommazahl

Zeichenkettenliterale:

in ' ' oder " "

Zeichenketten, die Zeichenkettenliterale oder Escape-Sequenzen enthalten

(durch " " begrenzt - Escape-Sequenzen: \n \t \a ...)

spezielle Literale:

Werden als eigenständige Wörter betrachtet und nicht interpretiert, wenn sie in Hochkommata

stehen:

_LINE_: aktuelle Zeilennummer (im Perl-Skript)

_FILE_: aktueller Dateiname (des Perl-Skriptes)

_END_: logisches Ende des Skript (Rest ignoriert)

3.2 Die Funktion '`print`'

Gibt eine Zeichenkette oder durch Komma getrennte Liste von Wörtern auf STDOUT aus.

(Erfolg Wert 1, sonst 0)

z.B.:

print "Guten","Tag","\n";

Leerzeichen müssen innerhalb " " angegeben werden!

oder:

print STDOUT Guten Tag, "\n";

Zeichenketten nicht in " " - Dateihandle muß angegeben werden!

print "Preis ist $100\n";

$=Sonderzeichen (skalare Var. referiert) $100 gibt es nicht, somit keine Ausgabe!

print "Preis ist \$100\n";

O.K.

print "\tnext\n";

Escape's werden interpretiert.

print '\tnext\n';

Nicht interpretiert - einfach alles so ausgeben.

3.3 Die Funktion '`printf`'

Formatierte Ausgabe einer Zeichenkette auf Dateihandle (default STDOUT).

Wie printf in C und awk.

Rückgabewert: 1 = Erfolg, sonst 0.

Syntax: printf ("Formatanweisung",Argumentliste);

in Formatanweisung Formatangaben - z.B. %d

Konvertierungzeichen:

c: Zeichen

d: Dezimalzahl

s: Zeichenkette

...

4 Variablen

4.1 Perl-Variablen

Variablen = Datenobjekte, deren Wert sich im Laufe des Programmes ändern kann

Perl kennt verschiedene Variablentypen:

Skalare: enthält einen einzigen Wert

Felder: Reihe von Werten mit positivem Index

assoziative Felder: als Index Zeichenketten

Sichtbarkeit = global (kann überall benutzt werden)

Variablen haben eigenen Namensraum (durch erstes Zeichen bestimmt):

$: skalare Variable

@: Feldvariable

%: assoziative Feldvariable

gleiche Namen möglich ($abc bzw. @abc)

Unterscheidung zwischen Klein- und Großbuchstaben

Variable beginnt mit Buchstaben ( _ gehört dazu) - kann beliebig lang sein

Variable beginnt nicht mit Buchstaben - darf genau ein Zeichen lang sein ($_ oder $.)

nichtinitialisierte Variable erhält Wert 0 bzw. NULL (leere Zeichenkette)

Zuweisung: Variable = Ausdruck;

z. B.:

$gehalt=10000;

@tage=(montag,dienstag,mittwoch);

%auto=('da','darmstadt', 'gg','groß gerau', 'g','gera',);

print "$gehalt"; - - - 10000

print "@tage"; - - - montag dienstag mittwoch

print "$tage[0]"; - - - montag

print "auto{'g'}"; - - - gera

Hochkommata bestimmen, wie Variablen interpretiert werden (ähnlich Shell)

drei Typen:

einfache

doppelte

accent graves (Gravis)

Backslash (\) wie einfache, aber nur für ein Zeichen

einfache oder doppelt - - - Begrenzung für Zeichenkette (bei doppelt: Sonderzeichen

interpretiert)

Gravis: Kommando ausgeführt

doppelte:

immer paarweise (außer '"' oder \")

skalare Variablen ($...) und Felder (@...) durch ihren Wert ersetzt

\n , \t: in " ", sonst nicht interpretiert

einfache:

so ausgegeben, wie angegeben (jedes Zeichen als Literal behandelt)

Gravis:

z.B.:

print "Datum:",`date`;

Kommando ausgeführt und Ergebnis eingesetzt

alternative Perl-Quotierungen:

q: ersetzt einfaches Hochkommata

qq: doppeltes

qx: ersetzt Gravis

Die zu quotierende Zeichenkette, steht in Schrägstrichen (/ ... /):
z. B.:

print q/ich brache $5/;

4.2 Skalare, Felder und assoziative Felder

4.2.1 Skalare Variablen

beginnen mit $ - enthalten Zahl oder Zeichenkette

es muß immer $ vorangestellt werden ! ($xy=13;)

Zuweisung - rechte Seite zu einem Skalar berechnet ($name="john smith";)

Funktion "defined" - Skalar hat weder gültige Zeichenketten noch gültigen numerischen Wert,

dann nicht definiert:

defined $var1; # Wert 1 gültig (sonst Null)

print "OK \n" if defined $var1;

Funktion "undef" - macht gültige Variable ungültig, Speicher wird freigegeben

Variable "$_" - enthält aktuelle Zeile (default-Suchraum für Mustersuchen) - wie $0 bei awk

4.2.2 Felder

über einen Namen auf Folge von elementen zugreifen (Name plus Index)

Elemente müssen nicht vom gleichen Typ sein (Zahlen und Zeichenketten können gemischt

werden)

Feld beginnt mit @

Indizies in [] mit Null beginnend

Zuweisung: @feld1=(100,"zk1",200,300,"last"); (Klammern notwendig, da Zuweisung höhere

Priorität als Kommaoperator!), z.B.:

@empty=(); #leere Liste

$size=@feld; #Wert des Skalars = Anzahl Feldelemente

spezielle Skalare und Feldzuweisungen:

$#Feldname: letzter Index des Feldes (Länge - 1)

$[: erster Index (gilt global/kein Feldname, normalerweise null, möglichst nicht verwenden!)

Bereichsoperator und Feldzuweisungen:

Bereichsoperator ".." - bei Feldern bekommt man ein Feld von Werten, das beim

linken Wert beginnt und beim rechten endet (um eins hochgezählt)

@ziffern=(0..10); -> Feld ziffern die Ziffern 0 bis 10 zuweisen

@Buchstaben=('a'..'z'); -> Liste Kleinbuchstaben

Zugriff auf Feldelemente:

Elemente sind Skalare und Index beginnt mit 0 ($feld[5])

Teilfelder:

Elementen eines Feldes werden Werte eines anderen zugewiesen: Ergebnisfeld = Teilfeld

Feld rechte Seite: restliche nicht zugewiesen

Feld links: nicht benutzte undefiniert

4.2.3 Assoziative Felder

besteht aus Paaren von Skalaren (Zeichenketten, Zahlen, Boolesche Werte)

erster Wert ist Index (Angabe Index in {} statt [ ]) z. B.:

%Jahreszeiten=(`F','Fruehling','S','Sommer','H','Herbst','W','Winter');

Zugriff auf Elemente:

über Index: umgeben von gescheiften Klammern:

print "Winter->$Jahreszeiten{`W'}";

print "alle->%Jahreszeiten"; #Reihenfolge eventuell anders!

4.3 Lesen von STDIN

drei Dateihandles STDIN, STDOUT und STDERR = Namen für drei vordefinierte Streams

stdin, stdout und stderr (normalerweise mit Terminal verbunden

Perl-Eingabeoperator <> umschließt Parameter STDIN, damit die nächste Eingabeziel

von der Tastatur gelesen und der Variablen zugewiesen werden kann - am Ende steht

"neue-Zeile-Zeichen" (löschen mit chop)

Zuweisen von Eingaben an skalare Variablen:

print "Bitte Namen eingeben! ";

$name=<STDIN>;

es wird Eingabezeile einschließlich "Neue-Zeile-Zeichen" gelesen

chop-Funktion

entfernt letztes Zeichen in einer Zeichenkette - hauptsächlich verwendet, um NewLine am

Ende einer Eingabezeile zu löschen:

print "Bitte Namen eingeben! ";

chop($name=<STDIN>);

getc-Funktion

liest ein einzelnes Zeichen von der Tastatur oder Datei (EOF: leere Zeichenkette)

Format:

getc (DATEIHANDLE)

getc DATEIHANDLE

getc

print "Klare Antwort (j/n) ";

$antwort=getc;

Zuweisen von Eingaben an Felder

beim Einlesen vom Dateihandle STDIN in ein Feld wird jede Zeile mit dem NewLine-Zeichen

gelesen und als ein Element des Feldes betrachtet (solange bis ^d):

print "Erzaehlen Sie alles ueber sich";

@all=<STDIN>;

print "@ll\n";

Zuweisen von Eingaben an assoziative Felder

$course_number=101;

print "Name fuer Kurs 101?";

$course{$course_number}=<STDIN>;

4.4 Feldfunktionen

Felder können wachsen und schrumpfen (Perl erlaubt Elemente am Anfang, in der Mitte oder am

Ende einzufügen oder zu löschen)

Funktion 'chop' (mit Feldern)

entfernt letztes Zeichen einer Zeichenketten und liefert diese Zeichen als Ergebnis

auf Feld angewendet -> letztes Zeichen jeder Zeichenkette im feld entfernt

@line=("rot","schwarz","orange");

chop(@line);

print "@line\n";

---> Ausgabe: ro schwar orang

Funktion 'grep':

grep (AUSDRUCK,LISTE)

Ausdruck auf jedes Elemet des Feldes LISTE angewandt

Rückgabewert = Feld, in dem die Elemente stehen, auf die der Ausdruck zutrifft

im skalaren Kontext - Rückgabewert wie oft Ausdruck zugetroffen hat

@list=(tomatoes,tomorrow,potatoes,phantom,Tommy);

$count=grep(/tom/i,@list); # => 4

@items=grep(/tom/i,@list); # => tomatoes tomorrow phantom Tommy

/tom/i - i schaltet Unterscheidung Groß-Kleinbuchstaben ab!

Funktion 'join':

verbindet Elemente eines Feldes zu einer einzigen Zeichenketten, wobei einzelne Elemente

durch das angegebene Trennzeichen getrennt werden (Umkehrfunktion zu split)

Format:

join(TRENNZEICHEN,LISTE)

$a1="eins zwei";

$a2="drei";

$a3="vier";

print join(":",$a1,$a2,$a3),"\n"; # => eins zwei:drei:vier

Funktion 'pop':

pop(FELD)

pop FELD

entfernt das letzte Element eines Feldes

@namen=("bob","dan","tom","guy");

$got=pop(@namen);

print "$got\n";

print "@namen\n";

Ausgabe:

guy

bob dan tom

Funktion 'push':

push(FELD,LISTE)

fügt Werte am Ende eines Feldes an

push(@namen,jim,archie); #-> zwei weitere Elemente zugewiesen

Funktion 'shift':

entfernt erstes Element und verschiebt alle anderen Elemente um 1 in Richtung des entfernten

Elementes

Feld wird um ein Element verkleinert:

shift(FELD)

shift FELD

shift # FELD nicht angegeben: ARGV genommen! (bei Unterprg "@_array")

@namen=("bob","dan","tom","guy");

$ret=shift @namen;

print "@namen\n"; # => dan tom guy

print "entferntes:$ret\n"; # => bob

Funktion 'splice':

entfernt und ersetzt Elemente in einem Feld

splice(FELD,OFFSET,LAENGE,LISTE)

splice(FELD,OFFSET,LAENGE)

splice(FELD,OFFSET)

OFFSET = erstes Element, was entfernt werden soll

LAENGE = Anzahl der zu entfernenden Elemente

LISTE = Liste von Elementen, die an Stelle der gelöschten Elemente einzutragen sind

@farben=(rot,schwarz,lila,blau,braun);

print "Original-> @farben\n";

@new=splice(@farben,2,3,gelb,orange);

print "entfernt->@new\n"; => lila blau braun

print "jetzt->@farben\n"; => rot schwarz gelb orange

Funktion 'split':

split(/TRENNZEICHEN/,AUSDRUCK,LIMIT)

split(/TRENNZEICHEN/,AUSDRUCK)

split(/TRENNZEICHEN/)

split

teilt Zeichenketten (AUSDRUCK) anhand von TRENNZEICHEN (default Blank)

Ergebnis = Feld von Elementen

keine Zeichenketten angegeben -> "$_" genommen

kein TRENNZEICHEN -> Leerzeichen, Tabulator und Neue-Zeile-Zeichen genommen

LIMIT = Anzahl der Elemente, die durch Aufteilen entstehen dürfen (überschüssige im letzten

Element zusammengefaßt)

Trennzeichen in Hochkomma -> Trennung wie awk (vorlaufende Leerzeichen ignoriert)

Trennzeichen in // -> leere Elemente erzeugt (=Anzahl Leerzeichen)

perl -ne `@str=split(/:/);print $str[0],"\n" ` /etc/passwd

# USER ausgeben

Funktion 'sort':

sort(UNTERPROGRAMM LISTE)

sort(LISTE)

sort UNTERPROGRAMM LISTE

sort LISTE

sortiert Feld und gibt es als Ergebnis zurück

kein UNTERPROGRAMM -> Zeichenketten-Vergleich

Funktion 'reverse':

reverse (LISTE)

reverse LISTE

vertauscht Reihenfolge in einem Feld

@namen=("bob","dan");

@re=reverse(@namen);

print "@re";

Funktion 'unshift':

unshift (FELD,LISTE)

fügt LISTE an den Anfang eines Feldes ein

@namen=(jody,bert);

unshift(@namen,liz,daniel);

print "@namen\n"; => liz daniel jody bert

4.5 Funktionen für assoziative Felder

Funktion 'keys':

keys (ASSOZIATIVES_FELD)

keys ASSOZIATIVES_FELD

liefert in einem Feld alle Schlüssel eines assoziativen Feldes (Reihenfolge zufällig!!)

Funktion 'values':

values (ASSOZIATIVES_FELD)

values ASSOZIATIVES_FELD

liefert in einem Feld alle Werte eines assoziativen Feldes (Reihenfolge zufällig!!)

Funktion 'each':

each (ASSOZIATIVES_FELD)

liefert die einzelnen Elemente eines assoziativen Feldes (Reihenfolge zufällig!!)

Ergebnis des Funktionsaufrufes=zweielementiges Feld (Schlüssel, Wert)

while( ($key,$value)=each %Wochentage ) { print "$key=$value\n"; }

Funktion 'delete':

delete $ASSOZIATIVES_FELD{SCHLUESSEL}

löscht ein Element in einem assoziativen Feld

erfolgreich -> gelöschter Wert als Ergebnis

5 Operatoren

5.1 Perl-Operatoren

manipulieren Datenobjekte (=Operanden)

Operanden=Zeichenketten, Zahlen oder Kombination von beiden

meiste Perl-Operatoren von C

5.2 Mischen von Datentypen

gemischte Operanden -> Perl prüft, was Operator erwartet und führt notwendige

Konvertierungen durch (Überlagerung des Operators genannt)

num. Operator und Operanden Zeichenketten - Zeichenketten in Gleitkommanzahlen konvertiert (vorlaufende Leerzeichen oder nachfolge nichtnumerische Zeichen ignoriert - Zeichenketten, die nicht konvertiert werden kann - Wert 0)

z.B.:

$x="   12!!"+"4\n";

print "$x";     # => 16

$y=ZAP . 5.5;

print "$y"; # => ZAP5.5

+ ist num. Operator -> Zeichenketten in Zahlen konvertiert

. ist Zeichenketten-Operator (verbindet zwei Zeichenketten) -> Zahl 5.5 in Zeichenketten

konvertirt und an ZAP angefügt

5.3 Priorität und Assoziativität

wenn Ausdruck mehrere Operatoren hat muß Rangfolge geregelt werden

Priorität: wie stark der Operator seine Operanden an sich bindet (Mult. bindet stärker als Add.),

Klammern binden am stärksten

Assozialtivität - Reihenfolge in welcher ein Operator seine Operanden evaluiert (l-r oder t-l)

z.B.:

$x=5 + 4 * 12/4;

print "Ergebnis:$x"; # => 17

Assoziativität l-r und */ vor + ===> ( 5 + ((4*12)/4) )

Priorität (absteigend) und Assoziativität:

Operator:                  Beschreibung:                Assoziativität:
============================================================================
() [] {}                   Funktionsaufruf, Feldindex   l-r

++ --                      Inkrement, Dekrement         keine

! ~ -                      logisches und bitweises      r-l
                           Nicht, unäres Minus

**                         Exponentation                r-l

=~ !~                      Übereinstimmend, nicht       l-r
                           übereinstimmend

* / % x                    Mult., Div., Modulo,         l-r
                           Zeichenketten-Wiederholung

+ - .                      Add., Sub., Verbinden von    l-r
                           Zeichenketten

<< >>                      Bitweises Verschieben        l-r

-r -w -x -o ...            Operatoren für Dateitest     keine





unäre Operatoren:


< <= > >= lt le gt ge      Vergleiche Zahlen und        keine
                           Zeichenketten

== != <=> eq ne cmp        Numerische und               keine
                           Zeichenketten-Vergleich

&                          Bitweises UND                l-r

|  ^                       Bitweises ODER und           l-r
                           exklusives

&&                         Logisches UND                l-r

||                         Logisches ODER               l-r

..                         Bereichsoperartor            keine

?:                         Ternärer Operator            r-l

= += -= *= /= %=           Zuweisung                    l-r

, (Komma)                  Kommaoperator                l-r

relationale Operatoren (Vergleiche):

Ergebnis wahr (1) oder falsch (0)

zwei Klassen:

Vergleich Zahlen

Vergleich Zeichenketten

5>4>3 - - # ist falsch (keine Assoziativität)

Zeichenketten:

relationale Operatoren gt, ge, lt und le

ASCII_Werte der einzelnen Zeichen verglichen

Operatoren für Gleichheit

numerisch:

== gleich

!= ungleich (nicht gleich)

<=> - z.B.: $num1 <=> $num2

Beide Werte verglichen - Rückgabewert:

1: num1 größer

0: gleich

-1: num1 kleiner

Zeichenketten:

eq - equal

ne - not equal

cmp - Ergebnis vorzeichbehaftet (wie <=>)

bedingter Operator:

Bedingung Ausdruck ? Ausdruck:Ausdruck

z. B.:

print "Wie alt?";

chop($age=<STDIN>);

$price=($age>60) ? 0:5.55;

printf "Sie zahlen \$%.2f.\n",$price;

Bereichsoperator:

print "@alpha"; A B C ... X Y Z

6 Reguläre Ausdrücke

6.1 Was ist ein regulärer Ausdruck?

Folge oder Muster von zeichen, das beim Suchen oder Ersetzen mit einer Zeichenketten

verglichen wird

normalerweise durch Schrägstriche begrenzt

z.B.: /abc/ -Muster in Textdatei gesucht -> jede Zeichenketten gefunden, die Muster abc enthält

?abc? - nur erster Vorkommen in einer Zeichenketten gefunden

6.2 Modifikation für Ausdrücke und einfache Anweisungen

einf. A.=Ausdruck, der von einem Semikolon beendet wird

Modifikatoren gestatten es, die Auswertung eines Ausdrucks von Bedingungen abhängig zu

machen

Modifikatoren:

if

unless

while

until

Bedingte Modifikatoren:

Format: Ausdruck2 if Ausdruck1;

print $x if $x ==5; # ausgeben wenn x=5

Format: Ausdruck2 unless Ausdruck1;

print $x unless $x==6; # bei x=6 nicht ausgegeben

Modifikator für Schleifen

Format: Ausdruck1 while Ausdruck2;

$x=1;

print $x++,"\n" while $x !=5; # 1 2 3 4

Format: Ausdruck1 until Ausdruck2;

print $x++,"\n" until $x==5; # 1 2 3 4

6.3 Operatoren für reguläre Ausdrücke

für Suchen und Ersetzen

Operator m

zur Suche von Mustern verwendet

m muß nicht angegeben werden, wenn Schrägstrich verwendet wird

soll anderes Zeichen verwendet werden (z.B. / kommt in zu suchender Zeichenketten vor) -

m muß angegeben werden

Format: m /Regulärer Ausdruck/

z.B.: m/Guten Morgen/ entspricht /Guten Morgen/

/\/usr\/var\/adm/ entspricht m#/usr/var/adm#

Operator s

Operator s/// wird für Ersetzungen verwendet

erster regulärer Ausdruck wird durch den zweiten ersetzt

auch anderes Trennzeichen möglich

g steht für globale Ersetzung innerhalb einer zeile (sonst nur erstes Vorkommen)

Format:

s/Alt/Neu/

s/Alt/Neu/g

s+Alt+Neu+g

Groß-und Kleinschreibung

bei Mustersuche unterscheidet Perl zwischen Groß- und Kleinschreibung

Abschalten "i" angeben

Format:

m/Muster/i

s/Alt/Neu/i

Zuweisungsoperatoren für Muster

um gefundenes Muster einer Variablen zuzuweisen

bisher Suchmuster immer auf Variable $_ angewendet (immer eine Zeile einer zu

verarbeitenden Datei)

auf andere Variablen anwenden -> Zuweisungsoperatoren erforderlich

Format:

Variable =Tilde /Ausdruck/

Variable !~ /Ausdruck/

Variable =~ /Alt/Neu/

$name="Tommy Tuttle";

$name=~ s/T/M/; nur erstes T durch M ersetzt

6.4 Metazeichen für reguläre Ausdrücke

Metazeichen stellen nicht sich selbst dar

Suchausdruck kann beeinflußt werden (z.B. am Anfang einer Zeile)

z. B.: /^a...c/

Metazeichen ^ (Zirkumflex) gibt an, daß Suchausdruck am Anfang einer Zeile stehen muß

Punkt steht für bel. Zeichen (auch Leerzeichen) - drei . = drei bel. Zeichen

Bedeutung Metazeichen durch "\" aufheben

sucht nach Ausdruck, wo a am Zeilenanfang-dann 3 bel. Zeichen und ein c

Beispiele Metazeichen:

        .               jedes Zeichen außer Neue-Zeile-Zeichen
        [a-z0-9]                jedes einzelne Zeichen in der Menge
        [^a-z0-9]       jedes einzelne Zeichen der Komplementmenge
        \D              Zeichen, das keine Ziffer ist (entspricht [^0-9])
        ^               Zeilenanfang
        $               Zeilenende
        x?              x kein- oder einmal
        x*              x kein-, ein- oder mehrmal
        x+              x einmal oder mehrmal
        x{m,n}          x mindestens m-mal und höchstens n-mal
        abc             steht für a, b und c
        wer|was|wo      entweder wer, was oder wo
        \1              das erste in Klammern angegebene Muster
        \3              das dritte in Klammern angegebene Muster

7 Schleifen

7.1 Kontrollstruk., Blöcke, zusammengesetzte Anwsg.

Programmablauf von Bedingungen abhängig machen

if, unless -> soll ein weiterer Block abgearbeitet werden

while, for, foreach - Schleifenanweisungen

Block=GRuppe von Anweisungen, die durch gescheifte Klammern zusammengefaßt werden

hinter if immer {} auch wenn nur eine Anweisung !!!

7.2 Entscheidungen

Anweisungen if und unless

Format: if (Ausdruck) {Block}

if (Ausdruck) {Block} else {Block}

if (Ausdruck) {Block} elsif (Ausdruck) {Block} ... else {Block}

if - Ausdruck wahr -> Block ausgeführt (bei unless - Ausdruck falsch ->Block ausgeführt)

Ausdruck im Zeichenketten-Kontext ausgewertet (Zeichenketten nicht leer -> wahr)

if (Ausdruck) {Block}

elsif (Ausdruck2) {Block}

elsif (Ausdruck3) {Block}

else {Block}

wahr -> Block hinter if

nicht wahr ->elsig geprüft (wieder falsch nächste elsif)

else nur, wenn alle elsif falsch

7.3 Schleifen

Schleifenkonstrukte in Perl:

while

until

for

foreach

jeder Schleife folgt Block mit Anweisungen in {}

while

Format: while (Ausdruck) { Block}

Block solange ausgeführt, wie Ausdruck wahr ist (ungleich Null/nicht leer)

while (1) # ist Endlosschleife!!

until

Format: until (Ausdruck) {Block}

Block solange ausgeführt, wie Bedingung hinter until falsch - Bedingung wahr-Schleife beendet

do/while und do/until

Format:

do {Block} while Ausdruck;

do {Block} until Ausdruck;

Berechnung erst, wenn Block mindestens einmal durchlaufen

for

wie for-Anweisung in C

Format:

for([Ausdruck1];[Ausdruck2];[Ausdruck3])

{ Anweisungsblock }

Ausdruck1 -> Initialwerte

Ausdruck2 -> Bedingung, ob Schleife fortgesetzt werden soll

Ausdruck3 -> Aktualisierung Schleifenvariable

z. B.:

for($i=0;$i<10;$i++)

{ print "$i"; } # 0 1 ... 9

foreach

geht über alle Elemente des in Klammern stehenden Feldes

jedes Element dem Skalar zugewiesen und der Block ausgeführt

Format:

foreach VARIABLE (FELD)

{ BLOCK }

VARIABLE -> lokal zum Block der Schleife foreach (nach verlassen ursprünglicher Wert)

keine VARIABLE -> $_ verwendet

z. B.:

@col=(rot,blau,braun);

foreach (@col) {

print "$_";

$_=ueber;

print "\n@col";

Ausgabe:

rot blau braun

ueber ueber ueber

Schleifenkontrolle:

Schleife ganz bzw. einen Schleifendurchlauf abbrechen

next -> nächster Schleifendurchlauf (C:continue)

last -> beendet Block (C:break)

redo -> Block von vorn ausgeführt ohne Bedingung zu prüfen

8 Arbeit mit Dateien

Dateihandle = Name einer Datei, ein Gerät, eine Pipe oder ein Socket.

8.1 Öffnen von Dateien

Funktion 'open' (definiert Dateihandle und weißt diesem Datei zu):

Format:

lesen:

open (DATEIHANDLE, DATEINAME)

open (DATEIHANDLE)

open DATEIHANDLE

schreiben:

open (DATEIHANDLE,">DATEINAME")

erweitern:

open (DATEIHANDLE,">>DATEINAME")

Pipe erzeugen:

open (DATEIHANDLE,"| KOMMANDO")

Pipe lesen:

open (DATEIHANDLE, KOMMANDO | )

open(IN,"myfile");

verbindet 'IN' mit Datei 'myfile' (lesen) - muß im aktuellen V. stehen, wenn kein vollständiger

Dateiname

open (in)

es muß vorher skalare Variable mit Namen des Dateihandle definiert werden, die Dateinamen

enthält: $in="myfile";

open (my,"/etc/password") || die "Datei kann nicht geoeffnet werden";

rechts vom log. Operator stehende Anweisung ausgeführt, wenn links falsch

schreibt Fehlermeldung mit aus (aus $!)

"\n" in Ausgabe - unterdrückt Ausgabe der Zeile, wo Fehler auftritt

open (pipe,"| wc -l");

print pipe "eins\nzwei\ndrei\n";

close (pipe);

- - - Ausgabe: 3

open (inp,"date |);

$today=<inp>;

close (inp);

print "\n$today";

8.2 Schließen von Dateien

Format:

close (DATEIHANDLE);

close DATEIHANDLE;

Datei bleibt sonst solange offen, bis das Skript beendet wird oder bis open erneut aufgerufen

(impliziert close)

8.3 Weitergeben von Argumenten

Feld ARGV

Kommandozeilenargumente in Feld ARGV gespeichert

Index beginnt mit Null! - - - ARGV[0] nicht Programmname, sondern erstes Argument

Variable $#ARGV = Nummer des letzten Feldindexes - also:

Anzahl der Argumente = $#ARGV+1 !

9 Unterprogramme

9.1 Definition

eigene Funktionen oder Unterprogramme erzeugen - zur sinnvollen Programmteilung - Module

genannt

Unterprogramm erst dann ausgeführt, wenn es aufgerufen wird - Unterprogramme sind global -

können an jeder beliebigen Stelle im Skript stehen

alle Var., die UP erzeugt oder auf die vom UP zugegriffen wird, sind innerhalb des Skriptes

global

Argumente werden als Referenzparameter übergeben - Adressen werden übergeben

(Argument ändern - Wert ändert sich auch)

Aufruf: &Unterprogramm; oder do Unterprogramm();

Rückgabewert ist der zuletzt berechnete Wert (Skalar oder Feld) - Funktion return kann auch

verwendet Werden (macht Programm langsamer!)

Format:

sub unterprogramm_name UP-Definition

{ block }

&unterprogramm_name; #Aufruf ohne Parameter

&unterprogramm_name(par_1, par_2, ...); #Aufruf mit Parameter

- z.B.:

sub bye {

print "$a";

$a=end;

}



$a=xyz;

if ( defined &bye) {

&bye;

}



print "$name"; #Ausgabe xyz

end;

9.2 Parameterübergabe

in Variablen @_ (Feld mit Namen _!) an das Unterprogramm übergeben

Elemente des Feldes @_ sind $_[0] ...

10 Schnittstellen zum Betriebssystem

Funktion getpwent:

gibt Informationen aus der /etc/passwd zurück, z.B.:

@info=getpwent;

print "@info";

Funktion exit:

beendet Programm (exit [(Zahl)];) - Zahl zwischen 0 und 255 ist ExitCode!

Funktion system:

ausführen von Kommandos

system ("UNIX-Kommando")

0 PERL - Ein 25-Minuten-Crashkurs!

0.1 Einleitung zum PERL-Crashkurs

1 Die Sprache PERL

2 PERL-Skripte

2.1 PERL in der Kommandozeile

2.2 Skript-Aufbau

3 Drucken

3.1 Wörter

3.2 Die Funktion 'print'

3.3 Die Funktion 'printf'

4 Variablen

4.1 Perl-Variablen

4.2 Skalare, Felder und assoziative Felder

4.2.1 Skalare Variablen

4.2.2 Felder

4.2.3 Assoziative Felder

4.3 Lesen von STDIN

4.4 Feldfunktionen

4.5 Funktionen für assoziative Felder

5 Operatoren

5.1 Perl-Operatoren

5.2 Mischen von Datentypen

5.3 Priorität und Assoziativität

6 Reguläre Ausdrücke

6.1 Was ist ein regulärer Ausdruck?

6.2 Modifikation für Ausdrücke und einfache Anweisungen

6.3 Operatoren für reguläre Ausdrücke

6.4 Metazeichen für reguläre Ausdrücke

7 Schleifen

7.1 Kontrollstruk., Blöcke, zusammengesetzte Anwsg.

7.2 Entscheidungen

7.3 Schleifen

8 Arbeit mit Dateien

8.1 Öffnen von Dateien

8.2 Schließen von Dateien

8.3 Weitergeben von Argumenten

9 Unterprogramme

9.1 Definition

9.2 Parameterübergabe

10 Schnittstellen zum Betriebssystem

3.2 Die Funktion '`print`'

3.3 Die Funktion '`printf`'