Perl - FOM

ausführbaren Maschinencode durch den Binder

• übersetzt Prograrmmcode in Maschinencode
• überprüft Quellcode auf korrekte Syntax
• bei Fehlerfreiheit Erzeugung des Objektcodes
• Zusammenfügung des Objektcodes mit benötigten Bibliotheksinhalten zum

• für schnell „zusammengeschusterte“ Programme
• optimiert zu ca. 90% für „Text-Probleme“
• für die Auswertung und Umwandlung von großen Datenmengen (Text,HTML-Format)
• für kleine CGI - Skripte (Programme, die von einem Webserver ausgeführt werden).
• Nur bedingt geeignet für lange und ausgedehnte Programme, für die ein Team von Programmierern längere Zeit benötigt

• Für das Erzeugen eines opaken Binärcodes
  • Programm in einem Format, welches die Codeinhalte nicht Preis gibt
• Weitergabe eines Perl-Programms -> Weitergabe des Quellcodes

: 

• unkompliziert
• Unterstriche sind erlaubt (Lesbarkeit)
• Nichtdezimale ganzzahlige Literale
• Zahlen zur Basis ungleich 10 erlaubt
• oktale (zur Basis 8) Literale:
  • Anfangszeichen: 0
• hexadezimale (zur Basis 16) Literale
  • Anfangszeichen: 0x
• binäre (zur Basis 2)
  • Anfangszeichen: 0b
• Sie bestimmen die für Sie am besten geeignete Darstellung!

Programmierbeispiel:


$i = 1745; # ganze Zahl
$j = 19.11; # Gleitkommazahl
$k = .35; # Gleitkommazahl, wie 0.35
$l = 24E-5; # zur Basis 10
$m = 7_408_999; # Lesbarkeit für große Zahlen
$n = 0xfa20; # hexadezimal
$o = 04363; # oktal
$p = 0b11111111; # binär

• Grundrechenarten: +, -, * und /
• Potenz: **
• Modulo: %
• Bit-Operatoren (ganze Zahlen): &, | und ˆ
• Inkrement / Dekrement: $n++; ++$n; $n--; --$n;
• Zuweisungen: =, +=, -=, *=, /=
• Vergleiche: ==, !=, <, >, <=, >=

Programmierbeispiel:
#Grundrechenarten: +, -, * und /
$zahl1 = 4;
$zahl2 = 2;
$ergebnis = $zahl1 + $zahl2;
print "Ergebnis (+): $ergebnis\n";

$ergebnis = $zahl1 - $zahl2;
print "Ergebnis (-): $ergebnis\n";

$ergebnis = $zahl1 * $zahl2;
print "Ergebnis (*): $ergebnis\n";

$ergebnis = $zahl1 / $zahl2;
print "Ergebnis (/): $ergebnis\n";

#Potenz: **
$ergebnis = $zahl1 ** $zahl2;
print "Ergebnis (**): $ergebnis\n";

#Modulo: %
$ergebnis = $zahl1 % $zahl2;
print "Ergebnis (%): $ergebnis\n";

• 'Single-quoted String'
o Zeichenkette umschlossen von einfachen Anführungszeichen
• (Hochkomma, Gegenhochkomma!(folgt))
• Anführungszeichen gehören nicht zum String
• Markierung des Anfangs und des Endes des Strings
• Interpretation z.B. der Zeichenfolge \n innerhalb eines Strings in einfachen
Anführungszeichen nicht als das Newline-Zeichen
o ein Backslash gefolgt von einem n.
• Sonderbedeutungen:
o der doppelte Backslash (\\)
o ein Backslash gefolgt von einem einfachen Anführungszeichen (\').

Programmierbeispiel:

$string1 = 'Otto'; # Die vier Zeichen: O, t, t und o
$string2 = '*Perl*'; # Diese sechs Zeichen
$string3 = ''; # Der Nullstring (keine Zeichen)
$string4 = 'Ein \'; #kann Ihren String frueher beenden, als Sie
denken.';
$string5 = 'Das letzte Zeichen dieses Strings ist ein Backslash: \\';
$string6 = 'Hallo\n'; # Hallo, gefolgt von einem Backslash, gefolgt
von einem n
$string7 = 'Hallo Welt!'; # Hallo, Leerzeichen, Welt! (insgesamt 11
Zeichen)
$string8 = '\'\\'; # Ein einfaches Anführungszeichen, gefolgt von
Backslash

• "Double-quoted Strings" - eine Folge von Zeichen umschlossen von
doppelten Anführungszeichen
• ähnliches Verhalten wie bei anderen Programmiersprachen
 

Programmierbeispiel:
$string1 = "Otto"; # das gleiche wie 'Otto'
$string2 = "Hallo Welt\n"; # Hallo Welt und ein Newline-Zeichen
$string3 = "Das letzte Zeichen ist ein doppeltes Anführungszeichen: \"";
$string4 = "string1\tstring2"; # string1, ein Tabulator String2
 

• Ersetzen von Variablen in Zeichenketten durch den aktuellen Wert

Drei Möglichkeiten:
• Keine Interpolation
o Hochkomma (bzw. „Tick“): »´«

Programmierbeispiel:
$string1 = "dir";
print "Ausgabe: $string1 \n";

$string2 = 'dir';
print 'Ausgabe: $string2\n';

$string3 = `dir`;
print "Ausgabe: $string3";


• Interpolation
o Doppelte Anführungsstriche: »”«
• Interpolation mit Standardausgabe des Kommandos
o Gegenhochkomma (bzw. „Backtick“): »`«


 

Operatoren für Strings:

.- Operator (Verkettung)
• Das „Aneinanderhängen“ von Stings
=, bzw. .= - Operatoren (Zuweisungsoperator)
• Das Zuweisen bzw. Aneinanderhängen des rechten Operators (String) an
den linken Operator (String)
x- Operator (Wiederholungsoperator)
• Das Kopieren und Aneinanderhängen des linken Operators (String) anhand
der Anzahl definiert durch den rechten Operator (Zahl)




 

Programmierbeispiel:

$string1 = "string1";
$string2 = "string2";

#Verkettung: .” ”.
$string3 = $string1 . $string2;
print "$string3\n";
$string3 = $string1 ."und". $string2;
print "$string3\n";

#Zuweisungen: = und .=
$string1 = "string1";
$string2 .= "stringX";
print "$string1\n";
print "$string2\n";

#Wiederholungen: $text = ”wichtig” x 8;
$string1 = "string1" x 5;
print "$string1\n";
$string2 = 5x(3+1);
print "$string2\n";

Programmierbeispiel:

$string1 = '44' eq '44.0'; # falsch (String-Vergleich)
$string2 = 'otto' lt 'lukas'; # falsch
$string3 = 'otto' lt 'ottoo'; # wahr
$string4 = 'otto' eq "otto"; # wahr
$string5 = 'otto' eq 'Otto'; # falsch
$string6 = 'c' gt 'b'; # wahr

• if - Kontrollstruktur
• alternative Auswahlmöglichkeit: elsif - Schlüsselwort
• alternative Auswahlmöglichkeit: else - Schlüsselwort
• Verwendung für alle Zweige von „{ . . . }“ zwingend notwendig
• Verknüpfung von Bedingungen durch „Bool’sche Operatoren“

Programmierbeispiel:

print "Bitte geben Sie Ihren Namen ein: ";
$name = <STDIN>;
print "Bitte geben Sie Ihr Alter ein: ";
$alter = <STDIN>;
print "Hallo $name";
print "Ihr Alter: $alter";
if( $alter < 20 )
{
print "Sie haben noch viel vor ...\n";
}
elsif( $alter <= 50 )
{
print "Sie sind zwischen 20 und 50 ...\n";
}
print "Sie haben es sich verdient ...\n";
}
else
{
 

Schleifenstrukturen in Perl:
• for
• while
• foreach
• do

Schleifenblöcke werden zwingend von „{ . . . }“ umschlossen.

Programmierbeispiel:
for ($i=0 ; $i < 3; ++$i)
{ print "*"; }
for $no (1..3) {
print ($no,"\n");
$no = 3;
while ($no > 0) {
print ("$no\n");
--$no;
@a=("hans","franz","paul");

foreach my $eintrag (@a)
{
print "$eintrag ";
}



}

}


 

Was passiert bei Verwendung einer skalaren Variable ohne Initialisierung?

• Vor der Initialisierung besitzen Variablen den speziellen Wert undef
• Verwendung dieses Werts als einen numerischen Wert ergibt: 0
• Verwendung dieses Werts als einen String ergibt: leeren String
• undef ist weder eine Zahl noch ein String
• undef ist eine eigenständige Art von skalarem Wert
• Verwendung von undef oft als Rückgabewert

Programmierbeispiel:

$n = 1;
while ($n < 10)
{
$summe += $n;
$n++;
}
print "Das Ergebnis lautet: $summe.\n";


$zeichenkette .= "hinzugefügt\n";
print "$zeichenkette\n";

• Erkennung, ob ein Wert tatsächlich undef ist oder ein leerer String

• der Zeileneingabeoperator <STDIN> liefert normalerweise den
eingegebenen Text
• Wird keine Eingabe vorgenommen (Ende einer Datei), dann liefert <STDIN> den Wert: undef
 

Programmierbeispiel:

$string ;

if ( defined($string) )
{
print "Der Inalt von \$string lautet: $string";
print "Der Inalt von \$string lautet: $string";
}
}
else
{