Embed Size (px)
Citation preview
Perl - Interpreter
Aufgabe des Perl-Interpreters ist dieUmsetzung des Skripts in MaschinenspracheUnd die direkte Ausführung des Programms!
#!/usr/bin/perl -w
# Die erste Anweisung. Alle Anweisungen sind immer mit# einem Semikolon zu beendenprint "Hallo Hugo\n"; # Eine Ausgabe mit Newline
$name = "Hugo"; # Eine Variable
print "Hallo $name\n"; # Ausgabe (interpoliert) # -> Hallo Hugo<LF>print 'Hallo $name\n'; # Uups! (nicht interpoliert) # -> Hallo $name\nprint "\n"; # Zeilenumbruch
$name = <STDIN>; # Eingabe über Tastatur (incl. # der abschließend. Returntaste)
Unser erstes Perl-Skript
Perl-Variablen (1) - Skalare Variablen
Perl kennt keine Datentypen wie integer, char, ... Skalare sind die wohl am meisten verwendete Form
von Variablen Einem Skalar können nach Belieben Werte
zugeordnet werden, gleichgültig ob Zahlen oder Buchstaben oder Zeichenketten (String)
Variablen müssen nicht definiert werden. Da wir hier aber einen mod_perl-Server verwenden (Erklärung folgt noch) sollten Sie davon keinen Gebrauch machen und alle Variablen mittels "my" definieren.
use strict # damit wir die Variablen nicht vergessen
#!/usr/bin/perl -w
# Damit wie die Variablendef. nicht vergessen könnenuse strict;
my $name; # Definition einer Variablenmy $alter; # Und noch einemy ($vorname, $groesse); # Oder etwas einfacher
$name = "Hugo"; # Zuweisung Zeichenkette$alter = 12; # Zuweisung Zahl$alter = "12"; # Zuweisung Zeichenkette$alter = $alter + 5; # Zeichenkette + Zahl
print "$name ist $alter Jahre alt\n"; # Das geht :-)
Unser zweites Perl-Skript
#!/usr/bin/perl -w
# Dies Skript berechnet den Flächeninhalt eines Rechtecks# nachdem Höhe und Länge über die Tastatur eingegeben worden sind
print "Bitte gib die Länge des Rechtecks ein: ";$laenge = <STDIN>;chomp($laenge);
print "\nBitte gib die Höhe des Rechtecks ein: ";$hoehe = <STDIN>;chomp($hoehe);
$ergebnis = $laenge * $hoehe;
print "Dein Rechteck hat den Flächeninhalt $ergebnis.";
# Mit dem Befehl chomp hat es folgendes auf sich: Wenn Du Deine Eingabe abgeschlossen hast, # schließt Du mit <RETURN> ab und sagst dem Skript so, daß die Eingabe vorgenommen # worden ist. Das Entscheidende ist, daß nun auch dieses <RETURN> Teil Deiner Eingabe ist. # Der chomp Befehl entfernt dieses ansonsten unsichtbare sogenannte newline Zeichen.
Unser drittes Perl-Skript
Perl-Variablen (2) - Arrays
Perl kennt neben Skalaren (durch ein $ gekennzeichnet wie z.B. $name, $vorname, ...) auch eindimensionale Felder (Array's). Deren Kennzeichen ist das @-Zeichen
Arrays bestehen aus einer Reihe von Skalaren Variablen
@Arbeitstage = ("Montag" , "Dienstag", “Mittwoch“, “Donnerstag“, “Freitag“);
Der Zugriff auf die einzelnen skalaren Elemente erfolgt durch einen in eckigen Klammern geschriebenen Index. Gestartet wird der Index mit dem Wert O, so dass mit dem Ausdruck $Arbeitstage[3] die Rückgabe des Donnerstags hervorgerufen wird.
#!/usr/bin/perl -w
use strict;my @arbeitstage; @arbeitstage = ("Montag" , "Dienstag", "Mittwoch", "Donnerstag");# Array mit 4 Feldelemente@arbeitstage = (@arbeitstage, "Freitag"); # 5 Feldelemente in @arbeitstage
# Einzelne Feldelemente sind Skalare!!! Man spricht# hier auch von 'skalarem Kontext'. Außerdem werden die# Feldelemente mit '0' beginnend indexiert
print "@arbeitstage \n"; # Ausgabe aller arbeitstageprint @arbeitstage. " \n"; # Ausgabe von 5print "$arbeitstage[1]\n"; # Ausgabe von Dienstag
Unser drittes Perl-Skript
Beispiel 1:Alle Elemtente eines Arrays durchlaufen#!/usr/bin/perl -wuse strict;my @arbeitstage;my $tag; @arbeitstage = ("Montag" , "Dienstag", "Mittwoch", "Donnerstag");
foreach $tag (@arbeitstage){
print $tag;print "\n";
}
Beispiel 2: Der Range Operator
@zahlen = (1 .. 1000)@alphabet = ("a" .. "z")
Weitere Beispiele
Perl-Variablen (3) - Hash
Eine weitere Datenstruktur sind assoziative Array's oder Hash'es. Ihr Kennzeichen ist das %-Zeichen
Hier erfolgt das Ansprechen der einzelnen Skalare nicht wie beim Array über einen vorgegebene Schlüssel, sondern über einen selbst definierten Suchschlüssel.
Einzelne Werte sind wieder als Skalare zu betrachten
#!usr/bin/perl%familie = ("22 " , "Mayer" , "24 " , "Mueller");print "$familie{22} \n ";print "$familie{24} \n ";
# In Zeile 2 werden dem Hash %familie die Schlüssel und # Werte zugeordnet. Reihenfolge immer Schlüssel - Wert.# In Zeile 3 und 4 werden nun über den Schlüssel die # zugehörigen Familiennamen ausgegeben
Bei einer langen Liste solcher Schlüssel- und Wert-Paare kann man leicht die Orientierung verlieren, was ein Schlüssel und was ein Wert ist. Um die Lesbarkeit solcher Hash-Initialisierungen zu erhöhen, bietet Perl einen speziellen Operator (=>) an.
%familie = (22=> “Mayer“, 24 => “Mueller“, 25 =>undef);
#!/usr/bin/perl -w
use strict;my (%familie, @array, $schluessel, $wert, $array, $familie);%familie = ("22" , "Mayer" , "24" , "Mueller");
print "Ein einzelner Wert:\n";print "$familie{22} \n";
print "\n Alle Schluessel:\n";foreach $schluessel (keys(%familie)){print "$schluessel\n";}#Die Funktion keys()liefert jeweils einen Schlüssel des Hashs und weist ihn der #Variablen $schluessel zu. Der Wert dieser Variablen wird dann innerhalb der #{} ausgeben. Die Funktion foreach () sorgt dafür, dass sich dieser Vorgang #solange wiederholt, wie Schlüssel im Hash vorhanden sind.
print "\n Alle Werte:\n";foreach $wert (values(%familie)){print "$wert\n"};#Ebenso wie alle verwendeten Schlüssel kann man auch alle verwendeten Werte #ausgeben.
print "\n Alle Wertepaare:\n"; #Die Funktion ermittelt ein Wertepaar undwhile(@array = each(%familie)) #übergibt Schlüssel und Wert an das @array.{
print "Schluessel: $array[0] -> "; #$array[0] enthält den Schlüsselprint "Wert: $array[1]\n"; #$array[1] den zugehörigen Wert
}
Unser viertes Perl-Skript
Übungsaufgabe 1
Schreiben sie ein Programm, dass nacheinander Tag, Monat und Jahr ihres Geburtstages einliest. Vergessen sie dabei nicht, vor jeder Eingabe einen kurzen Text zu platzieren.Auch das Programm selbst soll eine Überschrift auf dem Bildschirm erhalten, damit in knappen Worten Sinn und Zweck vom Benutzer erkannt werden können. Die Ausgabe soll anschließend formatiert ausgegeben werden: 1.1.1980.
Weitere Übungen
Übungsaufgabe 2:
Übungsaufgabe 3:
Übungsaufgabe 4:
Übungsaufgabe 5:
Übungsaufgabe 6:
Übungsaufgabe 7:
#!/usr/bin/perlprint "Dieses Programm gibt ihren Geburtstag aus.\n\n";print "Tag ihres Geburtstags eingeben (1-31): ";chomp($tag = <STDIN>);print "Monat ihres Geburtstags eingeben(1-12): ";chomp($monat = <STDIN>);print "Jahr ihrer Geburt eingeben: ";chomp($jahr = <STDIN>);print "Sie haben am $tag.$monat.$jahr Geburtstag.";
Die Hilfetexte werden mit der Funktion print() ausgegeben. Die Eingaben werdenvon STDIN, der Standard-Eingabe eingelesen. Diese Eingabe wird immer miteinem Zeilenumbruch beendet.
Um diesen Zeilenumbruch zu entfernen, wird das letzte Zeichen der Eingabe mitder Funktion chomp() entfernt. Nur so ist eine saubere Ausgabe des Geburtstagsmöglich.
Einlesen der einzelnen Daten und Entfernen des Zeilenumbruchs hätte auch inmehreren Schritten erfolgen können:
$tag = <STDIN>; chomp($tag);
Lösung Übungsaufgabe 1
Wichtige Kontrollstrukturen (foreach-Schleife)
Mit Hilfe einer foreach - Schleife kann jedes Element eines Arrays nacheinander abgearbeitet werden
foreach <Schleifenvar.> ( <Array> ){ <Schleifenkörper> };
#!/usr/bin/perl -w
use strict;my ($name, @namen);@namen = ("Andi", "Fritz", "Hugo");foreach $name (@namen){ print "Hallo $name\n";}
Wichtige Kontrollstrukturen (for-Schleife)
Bei der for-Schleife wird die jeweilige Anweisung sooft ausgeführt, wie als Zahlenwert angegeben wurde.
#!/usr/bin/perl -w
use strict;my ($i);
for ($i = 0; $i <15; $i+=1){
print “$i\n“;}
Wichtige Kontrollstrukturen (while-Schleife) Mit einer while-Schleife wird eine Anweisung so
lange wiederholt, bis ein vorher angegebener Wert erreicht wird.
#!/usr/bin/perl -w
use strict;my ($passwort);print “Passwort?“; # Fragt nach der Eingabe einer Zahl$passwort = <STDIN>; # Liest den Wert einchomp $passwort; # Letzte Zeichen der Eingabe wird gelöscht, also das drücken der RETURN-Taste.while ($passwort ne “hugo“) #Passwort ungleich Hugo{print “Falsches Passwort\n“; # Ausgabe: Falsches Passw.print “Neues Passwort eingeben\n“;# Eingabe: Neues Passwort$passwort = <STDIN>;chomp $passwort;}
Wichtige Kontrollstrukturen (until-Schleife) Mit einer until-Schleife erreicht man genau das
Gegenteil einer while-Schleife. So lange die vorher festgelegte Endbedingung nicht erfüllt ist, wird die Schleife fortgesetzt.
#!/usr/bin/perl -w
use strict;my ($passwort);print “Passwort?“; # Fragt nach der Eingabe einer Zahl$passwort = <STDIN>; # Liest den Wert einchomp $passwort;
until ($passwort eq “hugo“) #Passwort gleich Hugo{print “Richtiges Passwort\n“; print „Weiter geht`s.\n“; $passwort = <STDIN>;chomp $passwort;}
Wichtige Kontrollstrukturen(if-then-else)
Auch in Perl gibt es die allgemein bekannte if-then-else-Anweisung mit der Bedingungen überprüft werden.Die if-Anweisung besteht aus 3 Teilen:
if (zwingend)elsif (optional, mehrmalig)else (optional, einmalig)
Der Aufbau in korrekter Perl-Syntax sieht folgendermaßen aus:
if (Bedingung) {Anweisungsblock}elsif (weitere Bedingung) {Anweisungsblock}elsif (weitere Bedingung] {Anweisungsblock}else {Anweisungsblock}
Wichtige Kontrollstrukturen(if-then-else)
#!/usr/bin/perlmy ($alter);print "Wie alt bist du? ";$alter = <STDIN>;if ($alter<0){print "Ungültiges Alter!";}elsif ($alter<12){print "Du bist noch ein Kind.";}elsif ($alter>11 && $alter<18){print "Du bist ein Jugendlicher.";}else{print "Sie sind erwachsen.";}
Die wichtigsten Operatoren
Vergleichsoperatoren('binär') ('lexikalisch')
<<=>>===!=
ltlegtgeeqne
LogischeOperatoren
&&||!
UNDODER
Negation
Mathematische Operatoren
+-*/+=-=*=/=
%++--..=
Die Herren SkifahrerEine Aufgabe – 4 Lösungen
Lösungsmöglichkeit 1
#!/usr/bin/perl -w
use strict;
my($rang1, $rang2, $rang3, $rang4);
$rang1 = "Sprinzi-Stefan";$rang2 = "Felsen-Eddy";$rang3 = "Rau-Ralf";$rang4 = "Preschel-Sortus";
print "1. Platz $rang1\n";print "2. Platz $rang2\n";print "3. Platz $rang3\n";print "4. Platz $rang4\n";
Lösungsmöglichkeit 2
#!/usr/bin/perl -wuse strict;
my($name);my(@rang) = ("Sprinzi-Stefan", "Felsen-Eddy", "Rau-Ralf", "Preschel-Sortus", "Horn-Günthi");
print "Platz 1 und Goldmedaille: $rang[0]\n";print "Platz 2 und Silbermedaille: $rang[1]\n";print "Platz 3 und Bronzedaillie: $rang[2]\n";
Lösungsmöglichkeit 3
#!/usr/bin/perl –w
use strict;
my($i);my(@rang) = ("Sprinzi-Stefan", "Felsen-Eddy", "Rau-Ralf", "Preschel-Sortus", "Horn-Günthi");
foreach $i (0..4) {print "Platz ", $i+1, ": $rang[$i]\n";
}
Lösungsmöglichkeit 4
#!/usr/bin/perl -w
use strict;
my($name,$i);my(@rang) = ("Sprinzi-Stefan", "Felsen-Eddy", "Rau-Ralf", "Preschel-Sortus", "Horn-Günthi");
foreach $i (0..$#rang) { print "Platz ", $i+1; if ($i == 0) {
print " und Goldmedaille"; } elsif ($i == 1) {
print " und Silbermedaille"; } elsif ($i == 2) {
print " und Bronzemedaille"; } print ": $rang[$i]\n";}
Übungsaufgaben
Aufgabe 8: Schreiben sie ein Programm, welches zu einem beliebigen Namen einen entsprechenden Kommentar ausgibt.
Aufgabe 9: Schreiben sie ein Programm, welches bei der Eingabe eines beliebigen Namens einen entsprechenden Kommentar ausgibt. Das Programm aus Aufgabe 2, soll 4 mal durchlaufen werden.
Aufgabe 10: Schreiben Sie Programm, welches das kleine Einmaleins ausgibt.
Aufgabe 11: Schreiben Sie ein Skript, das den Benutzer zur Eingabe von zwei Zahlen auffordert und dann ein Array aus den Zahlen dazwischen erstellt (der Benutzer soll sowohl die niedrigere als auch die höhere Zahl als erste eingeben können).
Lösung Übungsaufgabe 8
#!/usr/bin/perl -w
use strict;my ($name, @namen);@namen = (“Thomas“, “Peter“, “Gerd“, “Benjamin“, “Maren“, “Kristina“, “Giuseppe“, „Frank“);foreach $name (@namen){ if($name eq ‘Thomas'){ print "Hallo Meister!\n"; } elsif($name eq ‘Peter' || $name eq ‘Kristina'){ print "Hallo $name, du Schwarzwaelder\n"; } else{ print "Hallo $name\n"; }}
Lösung Übungsaufgabe 9
#!/usr/bin/perl -wfor ($i=0; $i<4; $i+=1){print "Gib dein Name ein:\n";$namen = <STDIN>;chomp ($namen);if ($namen eq "Angela"){ print "Du bist willkommen";} elsif ($namen eq "Sabrina"){print "Du bist willkommen";}elsif ($namen eq "Valentina"){print "Du bist noch ein Kind aber du bist trotzdem willkommen";}else {print "Du bist nicht die gewuenschte Person! Versuch es noch einmal:\n";}$namen = <STDIN>;chomp ($namen);}
Lösung Übungsaufgabe 10
#!/usr/bin/perlprint "\nDas Kleine Einmaleins\n\n\n";for($i=1;$i<11;$i++) # Beginn der äußeren der beiden Schleifen
{ # beide Schleifen beginnen mit 1 und enden mit 10
for($j=1;$j<11;$j++) { printf "%5u",$i*$j; #Produkt beider Zählvariablen wird definiert und
} # auf 5 Stellen mit prinf ausgegeben
print "\n";}
#Im ersten Durchlauf wird also 1*1=1 ausgegeben, danach wird $j erhöht, der Anweisungsblock wiederholt und 1*2=2 ausgegeben. Nach $j010 wird 1*10=10 ausgegeben und die innere Schleife damit vorerst beendet. Anschließend sorgt ein Zeilenumbruch für die weitere Ausgabe in der nächsten ZeileNun ist der Anweisungsblock der äußeren Schleife einmal durchlaufen und $i wird auf 2 erhöht.
Lösung Übungsaufgabe 11
#!/usr/bin/perl -w
use strict;my $eins;my $zwei;my $array;
print 'Geben Sie eine Bereichsgrenze ein: ';chomp ($eins = <STDIN>);print 'Geben Sie die andere Bereichsgrenze ein: ';chomp ($zwei = <STDIN>);if ($eins < $zwei) {@array = ($eins .. $zwei);} else {@array = ($zwei .. $eins);}print "@array \n";
Die Funktion: printf
#!/usr/bin/perl$zahl1 = 6.44;$zahl2 = 62;$zahl3 = -0.1564;$zahl4 = 2.7;$zahl5 = 3827362.746;printf "%8.3f\n",$zahl3; # -0.156printf "%.0f\n",$zahl1; #6printf "%.0f\n",$zahl5; #3827363printf "%+-8.0fweiter\n",$zahl1; #+6 weiterprintf "%u\n",$zahl1; #6printf "%f\n",$zahl2; #62.000000printf "%.2f\n",$zahl4; #2.70printf "%u hexadezimal: %x\n",$zahl2,$zahl2; #62 hexadezimal: 3eprintf "%u oktal: %o\n",$zahl2,$zahl2; #62 oktal: 76printf "%.2e\n",$zahl5; #3.83e+006printf "%08u",$zahl2; #00000062
Erläuterung von printf
•%8.3f reserviert 8 Stellen zur Ausgabe der Zahl, 6 Stellen werden genutzt, Ausgabe ist rechts ausgerichtet, daher zu Beginn zwei Leerstellen,• %.0f rundet auf eine Ganzzahl, bis .5 wird dabei immer abgerundet,• %.0f rundet auf eine Ganzzahl, ab .5 wird aufgerundet,• %+-8.0f setzt ein +- Zeichen vor die Zahl, reserviert 8 Stellen, die Ausrichtung erfolgt links, daher zu Beginn keine Leerstellen wie in der ersten Zeile,• %u bewirkt die Ausgabe als Ganzzahl, im Gegensatz zu %.0f wird hier aber nicht gerundet, sondern nur die Nachkommastellen abgeschnitten.• %f bewirkt in diesem Fall die Ausgabe als Kommazahl, daher werden nach dem Komma noch einige 0 angefügt,• %.2f bewirkt die Ausgabe mit 2 Nachkommastellen, da 2.7 nur eine hat wird eine 0 angefügt,• %u ist bekannt, %x gibt dieselbe Zahl noch einmal hexadezimal aus,• %o gibt die Zahl oktal aus,• %e bewirkt die Ausgabe in wissenschaftlicher Form mit zwei Nachkommastellen,• %08u ergibt die Ausgabe 00000062, da insgesamt 8 Stellen für die Zahl reserviert sind, und alle vorderen Stellen mit einer 0 aufgefüllt sind.
$pfad =“c:\\readme.txt"; open(DATEI, $pfad); @inhalt=<DATEI>; close(DATEI); foreach $zeile (@inhalt) { print "$zeile\n"; }
Die erste Zeile definiert die Variable $pfad als den Pfad zu der Datei readme.txt (beachte, daß dem \ ein weiteres \ vorangestellt werden muß, damit es auch wirklich als \ interpretiert wird). Der open Befehl in der nächsten Zeile öffnet die Datei readme.txt in C:\ zum lesen und verknüpft die Datei mit einem sogenannten Dateihandle. Die Datei kann nun über diesen Alias angesprochen werden.
In unserem Fall lautet der Dateihandle schlicht DATEI. Der Dateihandle ist willkürlich gewählt. Wir hätten ihn auch MICKEYMAUS oder HELMUTKOHL nennen können. Du solltest Dateihandles immer GROß schreiben. Einen speziellen Dateihandle kennst Du eigentlich schon aus Kapitel 4 : <STDIN> ist das Dateihandle, das den Standard Input, also die Tastatur bezeichnet. Wir hatten ihn behandelt, als wir über Benutzereingaben sprachen.
In der nächsten Zeile, @inhalt=<DATEI>, wird der Inhalt der Datei in einem Rutsch in den array @inhalt gelesen, d.h. die erste Zeile von readme.txt ist das erste Element von @inhalt, die zweite Zeile von readme.txt ist das zweite Element von @inhalt etc. Beachte hierbei, daß das Einlesen aus readme.txt über den Dateihandle, dem Alias, DATEI in spitzen Klammern geschieht.
In der close Anweisung wird schließlich die Datei geschlossen, da der Lesevorgang beendet ist. Auch hier wird readme.txt über den Dateihandle DATEI angesprochen. Vergiß nicht eine Datei nach dem öffnen auch wieder zu schließen.
Die foreach Schleife ist wieder eine alte Bekannte: $zeile durchläuft elementweise den Array @inhalt und enthält die aus readme.txt eingelesenen Zeilen, die im Schleifenkörper ausgegeben werden. Du erinnerst Dich noch sicherlich, daß \n für ein newline steht, also einen Sprung in die nächste Zeile darstellt.
Arbeiten mit Dateien
Arbeiten mit Dateien
$pfad="C:\\notizblock.txt"; open(hugo, ">>$pfad"); do { print "Bitte geben Sie eine Notiz ein. Drücken Sie die <RETURN> Taste, wenn Sie keine Eingaben mehr wünschen: "; $notiz=<STDIN>; print hugo "Eintrag: $notiz\n"; } while ($notiz eq "\n"); close(hugo);
Der entscheidende Punkt ist hier das doppelte > in dem Ausdruck ">>$pfad", welches die Datei zum anhängenden schreiben öffnet. Innerhalb der do while Schleife wird mittels $notiz=<STDIN> solange nach einer Notiz gefragt bis der User die RETURN Taste drückt, um den Eingabevorgang abzuschließen; dies wird am Fuß der Schleife durch while ($notiz eq "\n") geleistet. Jede Eingabe $notiz wird innerhalb des Schleifenkörpers über den Dateihandle HELMUTKOHL der Datei notizblock.txt angehängt.
Subroutinen
Sub UnterprogrammName {
Anweisung;
return Wert;
}
- Unterprogramme werden mit dem Schlüsselwort sub gekennzeichnet.
- Danach folgt der Name des Unterprogrammes. Mit diesem Namen wird das Unterprogramm aufgerufen.
- In geschweiften Klammern wird der Anweisungsblock des Unterprogramms definiert.
- Soll das Unterprogramm einen Wert zurückliefern, muss er mit dem Schlüsselwort return festgelegt werden. Der Rückgabewert kann eine Variable, das Ergebnis eines Ausdrucks oder ein konstanter Wert sein.
Subroutinen
# Hauptprogramm
print "Wie ist Dein Name? \n";# Aufruf der Unterroutine hello &hallo();
# Unterroutinensub hallo {print "Hallo, mein Name ist Henning.\n";}
Wie wahrscheinlich jeder erraten wird, gibt dieses Skript die Texte Wie ist Dein Name? und Hallo, mein Name ist Henning aus. Von der enormen Leistungsfähigkeit dieser Unterroutine abgesehen, kann man hier das oben bereits erwähnte erkennen:Die Unterroutine wird über &hallo() aufgerufen, schließlich gibt die Unterroutine nach Ihrem Aufruf den ersten Text auf dem Bildschirm aus. Hiernach läuft das Hauptprogram weiter und gibt den zweiten Text aus. Das Skript ist hiermit beendet.Die Unterroutine wird am Ende nicht nocheinmal abgearbeitet bzw. alle mit mit dem Schlüsselwort sub beginnenden Anweisungsteile am Ende des Skripts sind nur Definitionen. Eine Subroutine muß zu Ihrer Ausführung explizit mit Namen aufgerufen werden.
Subroutinen - Beispiel#!/usr/bin/perl
&Eingabe;&Berechnung;&Ausgabe;
sub Eingabe { print "Volumen-Berechnung eines Quaders\n\n"; print "Bitte geben Sie Höhe, Breite und Tiefe in m ein. "; print "Trennen Sie die Werte durch ein Leerzeichen.\n"; $werte=<STDIN>; chomp($werte); @werte=split(/ /,$werte); #split = wandelt eine Zeichenkette in ein Array um}
sub Berechnung { $volumen=$werte[0]*$werte[1]*$werte[2];}
sub Ausgabe { print "Das Volumen beträgt $volumen m³\n\n";}
Übungsaufgabe 12
Schreiben Sie ein Programm, welches Vorname, Name, Strasse, PLZ, Ort, Telefon und die E-Mail Adresse von Schülern abfragt und alle Daten in die Datei schuelerdaten.txt speichert.
Verwenden Sie wenn möglich Subroutinen!
Lösung 1
#!usr/bin/perl
@daten=($name,$vorname,$strasse,$plz,$stadt,$nummer);
$pfad = "C:\\schuelerdaten.txt";open(datei, ">>$pfad");do {print "Hallo Schueler\n";print "Bitte gebe deinen Namen ein;\n";$name=<STDIN>;chomp($name);print "OK Schueler $name, nun bitte den Vornamen\n";$vorname=<STDIN>;chomp($vorname);print "Bitte gebe deine Strasse ein;\n";$strasse=<STDIN>;chomp($strasse);print "Ok. Schueler $name $nachname. Bitte gebe deine PLZ ein;\n";$plz=<STDIN>;chomp($plz);print "Ok. Schueler $name $nachname. Bitte gebe deine Stadt ein;\n";$stadt=<STDIN>;chomp($stadt);print "Ok. Schueler $name $nachname aus $stadt. Bitte gebe deine Telefonnummer ein;\n";$nummer=<STDIN>;chomp($nummer);print "OK. Du bist $name $vorname und wohnst im/in der $strasse in $plz $stadt und wir erreichen die unter $nummer\n";print datei "Eintrag:$name\n $vorname\n $strasse\n $plz\n $stadt\n $nummer\n";}while (@daten eq "\n");close(datei);
Lösung 2
#!/usr/bin/perl -w
$pfad = "c:\\schuelerdaten.txt";open(DATEI, ">>$pfad");do{&Eingabe;&Ausgabe;
sub Eingabe {print "Gib deinen Namen, Vornamen, Strasse, PLZ, Stadt, Telefon und deine E-mail adresse ein!";print "Bitte trenne deine Eingaben durch ein Komma!\n";$werte = <STDIN>;chomp($werte);@werte =split(/,/,$werte);}sub Ausgabe {print DATEI "$werte";#print "Deine Angaben:\n $werte[0] $werte[1]\n $werte[2]\n $werte[3] $werte[4]\n $werte[5] $werte[6]\n";# Keine Ausgabe in der Konsole}}while ($werte eq "\n");close(DATEI);
Übergabe von Argumenten und Rückgabe von Werten
Argumente übergeben:Argumente sind Parameter, die man beim Aufruf eines Unterprogramms übergeben und innerhalb des Unterprogramms verarbeiten kann. Die Argumente werden in runde Klammern eingeschlossen und an den Namen des Unterprogramms angeschlossen. In Perl werden die Argumente stets mithilfe des vordefinierten Arrays @_ zur Verfügung gestellt.
Syntax des Aufrufs von Unterprogrammen mit Argumenten:
&UnterprogrammName (Argument1, ...);
Durch die besondere Art der Parameterübergabe kennt Perl keine benannten Argumente. Den ersten übergebenen Parameter erhält man über die Variable $_[0], den zweiten über $_[1] usw.
Rückgabewert:Wenn nötig kann man in einer Funktion einen Rückgabewert definieren. Dies kann beispielsweise das Resultat einer Berechnung oder ein Wahrheitswert sein. Der Rückgabewert wird mit dem Schlüsselwort return festgelegt. Sie können skalare Variablen, aber auch Arrays oder Hashes zurückgeben.
sub Summe$a = 10;$b = $a + 5;return $b; # Rückgabewert des Unterprogramms ist 15;
Übergabe von Argumenten und Rückgabe von WertenBeispiel: Das Perl-Programm soll mithilfe einer Funktion die kleinste von einer beliebigen Anzahl Zahlen bestimmen. Die Zahlen werden mit Leerzeichen getrennt, über die Tastatur eingegeben. Die eingegebenen Werte werden dem Unterprogramm als Argument übergeben. Als Ergebnis liefert es die kleinste Zahl.
#!/usr/bin/perl&Eingabe;&Ausgabe;sub Eingabe { print "Geben Sie eine beliebige Anzahl Zahlen ein.\n\n"; print "Trennen Sie die Zahlen jeweils durch ein Leerzeichen.\n"; $werte=<STDIN>; chomp($werte);}sub Ausgabe { print "Die kleinste Zahl ist ".&Kleinste($werte);}sub Kleinste { local $kleinste; @werte=split(/ /,$_[0]); foreach(@werte) { if (!$kleinste) { $kleinste=$_; } elsif ($_<$kleinste) { $kleinste=$_; } } return $kleinste;}
Referenzen verwenden
1. Array als Argumente von Unterprogrammen
Wenn man ein Array als Argument übergibt, verliert es seine Eigenständigkeit. Es wird in seine Elemente aufgegliedert, auf die man über das vordefinierte Array @_ innerhalb des Unterprogramms zugreifen kann.
Beispiel 1:&Summe ($zahl1, @zahlen, $zahl2);Innerhalb des Unterprogramms enthält das Array @_ die Werte in folgender Reihenfolge:@_ = ($zahl1, $zahlen[0], $zahlen[1], ....., $zahlen[n], $zahl2);
Soll das Array erhalten bleiben, muss man es als Referenz, d.h. als Zeiger auf einen Speicherplatz, übergeben.
Beispiel 2:&Summe ($zahl1, \@zahlen, $zahl2);In diesem Fall wird eine Referenz auf das Array @zahlen übergeben:$zahl1 = $_[0];$zahlen = @{$_[1]};$zahl2 = $_[2];
Referenzen verwenden
2. Referenzen auf Variablen erstellenReferenzen auf eine Variable erstellt man durch das Voranstellen eines Bachslashs vor den Variablennamen. Man kann Referenzen auf skalare Variablen, Arrays, Hashes oder andere Referenzen erstellen. Die Referenz selber ist ein skalarer Wert und kann in einer entsprechenden Variablen oder in einem Arrayelement gespeichert werden.
Beispiel:$referenz = \$wert; # Referenz auf eine skalare Variable$referenz = \@werte; # Referenz auf ein Array$referenz = \%werte; # Referenz auf ein Hash
3. DereferenzierungEine Referenz enthält nur die Speicheradresse einer Variablen. Um wieder auf den eigentlichen Wert der Variablen zugreifen zu können, müssen Sie eine Dereferenzierung durchführen. Dabei wird die Speicherreferenz aufgelöst. Bei der Dereferenzierung wird der Referenzvariablen das ursprüngliche Kennzeichen des Datentyps ($, @, %) vorangestellt.
Beispiel:$referenz = \$wert; # Referenz auf eine skalare Variableprint $$referenz; # Ausgabe des ursprünglichen Wertes
$referenz = \@werte; # Referenz auf ein Array@array = @$referenz # Zugriff auf das ursprüngliche ArrayPrint $$referenz[0]; # Ausgabe eines einzelnen Elements
Vordefinierte Perl - FunktionenNeben den Unterprogrammen, die man selbst erstellt, enthält Perl bereits eine grosse Zahl vordefinierter Funktionen. Die Syntax des Aufrufs von Perl internen Funktionen erfolgt über $variable = funktionsname (Argumente);Falls ein Ergebnis zurückgeliefert wird, kann es einer Variablen zugewiesen oder in einem Ausdruck (print “$variable“) verwendet werden.
Funktion Erklärung Beispiel Ergebnis
chomp ($str); Löscht den Zeilenumbruch \n am Ende der Zeichenkette
chomp (“Welt \n“);
“Welt“
chop ($str); Löscht das letzte Zeichen einer Zeichenkette
chop (“Welt“); „Wel“
lc ($str)
lcfirst ($str)
Umwandlung in Kleinbuchstaben
Nur erstes Zeichen umwandeln
lc (“Welt“); “welt“
uc ($str)
ucfirst ($str)
Umwandlung in Großbuchstaben
Nur erstes Zeichen umwandeln
uc (“Welt“); “WELT“
sprintf (“Format“, $variable);
Formatierte Ausgabe von Werten sprintf (“%.2f“, 23.5);
23.50
int ($zahl) Liefert den ganzzahligen Teil einer Dezimalzahl
int (24.75) 24
rand ($zahl) Liefert eine Zufallszahl, die kleiner ist als $zahl
rand (6) 5.4071
srand ($zahl) Initialisiert den Zufallsgenerator srand (time ^ $$)
split (/ /, $str); Wandelt eine Zeichenkette anhand eines Trennzeichens in ein Array
split (/ /, “Hallo Welt“);
“Hallo“
“Welt“
Übungsaufgaben
Aufgabe 12:
• Erstellen Sie ein Programm, das Zufallszahlen für das Lottospiel 6 aus 49 erzeugt.• Initialisieren Sie den Zufallsgenerator mit der entsprechenden Funktion.• Kapseln Sie die Erzeugung einer einzelnen Lottozahl in einem Unterprogramm
LottoZahl.• Beachten Sie, dass die Funktion zur Erzeugung einer Zufallszahl beim Wert 0
beginnt und Dezimalzahlen liefert.• Rufen Sie das Unterprogramm in einer geeigneten Schleife sechsmal auf, und geben
Sie das Ergebnis aus.• Verändern Sie das Programm so, dass es keine doppelten Zufallszahlen erzeugt. Zu
diesem Zweck können Sie die erzeugte Zahl als Schlüsselwert in einem Hash verwenden.
Aufgabe 13:
• Das Programm soll mithilfe eines Unterprogramms prüfen, ob ein über die Tastatur eingegebener Städtenamen in einem Array vorhanden ist.
• Erzeugen Sie ein Array mit verschiedenen Städtenamen.• Erstellen Sie eine Tastaturabfrage, um den Namen einer Stadt einzulesen. Denken Sie an das
Entfernen des Zeilenvorschubs am Ende der Eingabe.• Die Unterfunktion soll zwei Argumente erhalten. Das erste Argument ist die gesuchte Stadt.
Als zweites Argument soll das Array mit den Städtenamen übergeben werden. Damit das Array erhalten bleibt, müssen Sie es als Referenz übergeben.
• Erzeugen Sie im Unterprogramm zwei lokale Variablen für den Namen der Stadt und die Städteliste.
• Weisen Sie den lokalen Variablen die übergebenen Werte zu. Dereferenzieren Sie dabei den Verweis auf das Array.
• Durchlaufen Sie in einer Schleife die Elemente des Arrays, und prüfen Sie, ob der Stadtname vorhanden ist. In diesem Fall soll der Wert 1 (true) zurückgegeben werden.
• Ist die Stadt nicht gefunden worden, soll das Unterprogramm den Wert 0 (false) liefern.• Bearbeiten Sie den Vergleich so, dass die Groß- und Kleinschreibung keine Rolle spielt.• Rufen Sie das Unterprogramm auf, und geben Sie je nach zurückgeliefertem Ergebnis eine
entsprechende Meldung aus.
Lösungen zu den Übungsaufgaben
Aufgabe 12:
#!/usr/bin/perl
srand(time ^ $$);
print "Das Programm erzeugt Zahlen für das Spiel 6 aus 49:\n";
for($i=1;$i<=6;$i++) {print &LottoZahl." ";
}
sub LottoZahl {do {
$zahl=int(rand(48)+1);} while (exists($zahlen{$zahl}));$zahlen{$zahl}=1;return $zahl;
}
Aufgabe 13:
#!/usr/bin/perl
@staedte=qw(Berlin Leipzig München Hannover Rostock Stuttgart Köln);
print "Bitte geben Sie einen Städtenamen ein: ";$stadt=<STDIN>;chomp($stadt);if (PruefeStadt($stadt,\@staedte)) {
print "$stadt ist in der Liste enthalten\n";} else {
print "$stadt ist nicht in der Liste enthalten\n";}
sub PruefeStadt {local ($stadt,@liste);$stadt=$_[0];@liste=@{$_[1]};foreach(@liste) {
if (lc($_) eq lc($stadt)) {return 1;
}}return 0;
}
1. Schreiben Sie ein Divisions-Skript, in dem Sie um die Eingabe von zwei Zahlen bitten und prüfen, dass keine der eingegebenen Zahlen negativ und die zweite Zahl nicht Null ist. Wenn beide Zahlen diesen Anforderungen entsprechen, teilen Sie die erste durch die zweite Zahl, und geben Sie das Ergebnis aus.
2. Schreiben Sie ein Skript, das Sie um zwei Arrays bittet und dann ein drittes Array erstellt, das nur die Elemente enthält, die in beiden anderen Arrays vorkommen (die Schnittmenge dieser Arrays).
Weitere Übungsaufgaben
#!/usr/bin/perl -w
print 'Geben Sie die erste Zahl ein: ';chomp($zahl1 = <STDIN>);print 'Geben Sie die zweite Zahl ein: ';chomp($zahl2 = <STDIN>);if ($zahl1 < 0 && $zahl2 < 0) {print "Keine negativen Zahlen!\n";} elsif ( $zahl2 == 0) {print "Die zweite Zahl darf nicht 0 sein!\n";} else {print "$zahl1 geteilt durch $zahl2 ist ";$ergebnis = $zahl1 / $zahl2;printf("%.2f\n", $ergebnis );}
Übungsaufgabe 1
#!/usr/bin/perl -w
print 'Geben Sie das erste Array ein: ';chomp($input = <STDIN>);@array1 = split(/ /, $input);print 'Geben Sie das zweite Array ein: ';chomp($input = <STDIN>);@array2 = split(/ /, $input);
foreach $el (@array1) {foreach $el2 (@array2) {if (defined $el2 && $el eq $el2) {$final[$#final+1] = $el;undef $el2;last;}}}
print "@final\n";
Übungsaufgabe 2
