• TU Chemnitz
• URZ
• Kurse
• Unterlagen
• Perl in der Praxis

Perl in der Praxis

Frank Richter, URZ, Januar 2008

Historie und Eigenschaften

• UNIX-Administrator: Sammlung von Shell-Skripten und umfangreichen awk-Programmen
• unzufrieden - entwickelte eigene Skriptsprache, bis er zufrieden war

Ergebnis: Perl - Practical Extraction and Report Language

• Best of C, Shell, awk, sed ...
• Veröffentlicht im Internet - enormer Zuspruch
• GNU General Public License oder Artistic License
• Die Skriptsprache von UNIX-Admins
• WWW - CGI-Programme: Perl die erste Wahl

• Schließt Lücke zwischen pragmatischer, aber oft ineffizienter/umständlicher Shell-Programmierung und performanter, aber recht umständlich handhabbarer Programmiersprache C
• für "jede" Plattform
• große Entwicklergemeinschaft
• jede Menge Literatur
• Newsgruppen comp.lang.perl, de.comp.lang.perl
• WWW-Server: www.perl.com, www.perl.org

Großer Funktionsumfang:

• Datentypen, Operatoren, Konstrukte, Funktionen, Klassen
• Quasi-Standard: Perl regular expressions (PCRE)
• kompakte, z.T. "kryptische" Notation
• häufig mehrere Wege für eine Lösung
• Module für jede Aufgabe: CPAN (Comprehensive Perl Archive Network)

Eingesetzt z.B. in

• TWiki - Wiki-Autorensystem
• OTRS - Open Ticket Request System

Konkurrenz:

• Python als moderne Skriptsprache
• PHP im WWW-Umfeld
• Ruby (on Rails)

Interpreter-Sprache:

• Zu Beginn wird gesamtes Skript eingelesen und syntaktisch geprüft.
• -> Opcode - hohe Performance
• kurzer Entwicklungszyklus: Text-Editor, Aufruf

Dokumentation und Literatur

Linux - englisch:

• man perl
• man perlfunc ...

• perldoc -f print - Hilfe zu Funktion
• perldoc -q muster-in-FAQ

WWW - englisch:

• www.perl.com
• www.tu-chemnitz.de/docs/perl.html

Bücher - deutsch:

• RRZN-Handbuch: Perl - Eine Einführung (via URZ, 3 Euro)
• Ditchen, Patrick: Perl - Schritt für Schritt zum Profi (in 21 Tagen)
• Randal L. Schwartz, Tom Phoenix: Einführung in Perl (Learning Perl)

Formalitäten

• Perl-Skript = Text
• formatlos, d.h. Anzahl der Leerzeichen, Leerzeilen usw. egal
• jede Anweisung mit Semikolon abschließen
• Blöcke durch { ... }
• # Kommentar bis Zeilenende - Kommentare sind sehr wichtig!

Aufruf

• Skript in Datei hallo.pl
print "Hallo Welt!\n";
  • Aufruf: % perl hallo.pl

• "Shebang" - erste Zeile in hallo.pl
#!/usr/bin/perl
print "Hallo Welt!\n";
  • chmod +x hallo.pl
  • Aufruf: % ./hallo.pl

• Von Kommandozeile: % perl -e 'print sin(1.5)'

• Zum Test:
  % perl
  beliebiger Perl-Code
  ^D

• Weitere Kommandozeilen-Optionen

Variablen (1)

• müssen nicht zwingend deklariert und initialisiert werden - macht Perl implizit
• toll für kleine Skripte
• Initialisierung empfohlen für größere Projekte

use vars qw($zaehler @array);   # Deklaration von globalen Variablen
$zaehler = 0;                   # Initialisierung
@array = ();

Skalare

Immer $-Zeichen: bei Wertzuweisung und bei Zugriff auf Wert.

Zahlenwerte

$int = 123;          # ganze Zahl
$oktal = 040;        # Oktal, = 32 dezimal
$hexadezimal = 0x42; # Hexadezimal, = 66 dezimal
$float = 4.56;       # Dezimalbruch mit Punkt
$_12 = 12E-5;        # Exponentialdarstellung: "12 mal 10 hoch -5" = 0.00012

Arithmetische Operationen:

• Zuweisung: =
• Grundrechenarten: $a = 4 + 1; $b = ($a - 2) * 3;
• Modulo %, Potenz **, Wurzel: print $b ** 0.5;
• Kurzschreibweise: $b /= 3; # $b = $b / 3;
• In-/Dekremtieren: ++$a; $b++; $c = $b--;
• Reihenfolge (Präzedenz) vgl. C, am besten Klammern setzen

Numerische Vergleiche:

• Gleich, ungleich: $b == 3; $b - 1 != 3
• größer, kleiner (gleich): $alter >= 18

Mathematische Funktionen:

• Winkelfunktionen: sin($x); cos($x); atan2($x, $y);
• Exponential-, Logarithmusfunktion: $e = exp(1); log($e);
• Konvertierung: $i = hex(16); print int($i/7);
• Zufallszahl: print int(rand(10));   # zwischen 0 und 9 (inkl.)

Bitoperationen (ähnlich C): print 0x10 << 2 | 2;

Viele mathematische Zusatz-Module:

• Integer-Zahlen beliebiger Länge: use Math::BigInt;

Zeichenketten

$string1 = '456';                 # Keine Substitution, außer \' = ', \\ = \
$string2 = "Hallo $string1!\n";   # Doppel-Apostroph: Variablen-Substition, \-Sonderzeichen
print "\e[38m Roter Text\e[0m\n"; # Escape-Sequenz
$html = <<END;                    # sog. Here-Dokument
<html><head>
 <title>$string2 ...
END

Zeichenketten-Operatoren:

• Verkettung: $url .= '.html'; print '<a href="' . $url . '">';
• Wiederholung: $trenner = '-' x 80;

Vergleichsoperatoren: eq - gleich, ne - ungleich: if ($string1 eq $string2) {...}

Vielzahl von Zeichenketten-Funktionen:

  $laenge = length($trenner);           # 80
  print lc($string2);                   # Kleinschreibung, uc = Großschreibung
  print ucfirst('gross und Stark');     # nur erster Buchstabve groß: Gross und Stark
  chomp($zeile);                        # entfernt abschließendes Newline
  $teil = substr('26 Juni 2007', 3, 4); # Teilzeichenkette: Juni
  substr($teil, 2, 1) = 'l';            # Ersetzen: Juli

Ausgabe / Formatieren:

• print zeichen, variablen ...;
• Formatiert:
  • printf(format, argumente...);
  • $s = sprintf(format, argumente...);
• format "wie aus C gewohnt" http://www.tu-chemnitz.de/docs/perldoc/functions/sprintf.html

$fahrenheit = 20;
$celsius = ($fahrenheit - 32) * 5 / 9;

print "$fahrenheit F = $celsius C\n";
# Besser: gerundet auf eine Nachkommastelle
printf("%d F = %5.1f C\n", $fahrenheit, $celsius);

Reguläre Ausdrücke:

• if ($string =~ /muster/) { ... }
• später ...

Spezial-Variablen, z.B.:

• $0 - Skriptname
• $_ - Standard-Variable, in Schleifen gesetzt, z.B. von Funktionen als Standard-Argument verwendet
• $$ - Prozess-ID (wie in Shell)
  viele weitere ...

Datei-Testoperationen

• Ähnlich test bzw. [ ... ] in der Shell:

Logische Operatoren

• UND- bzw. ODER-Verknüpfung, NOT bzw. XOR:

if ($a > 0 && $a <= 100)          # $a zwischen 1 und 100 (inkl.), auch and
if ($s eq 'y' || $s eq 'j')       # $s gleich y oder j, auch or
if (! $s)                         # $s ist leer oder Null

Bedingte Anweisungen: $a < 10 && print "$a kleiner 10\n";

Weitere Operatoren: http://www.tu-chemnitz.de/docs/perldoc-html/perlop.html

Steueranweisungen

Verzweigungen

if (Bedingung) {
   # Anweisungen: wenn Bedingung wahr
} elsif (andere Bedingung) {
   # Anweisungen: wenn andere Bedingung wahr
} else {
   # sonst diese Anweisungen
}

Bedingung = logischer Ausdruck:

• alles Mögliche: Vergleichsoperation, Muster, Datei-Testoperation, Funktionsruf
• beliebig logisch verknüpft
• falscher Wert: Zahl 0, Zeichenkette '0' oder leer
• alles andere ist wahr

Bedingte Anweisung: print "$a kleiner 10\n" if ($a < 10);

Bedingungsoperator ? - wie in C:

• $anrede = $geschlecht eq 'm' ? 'Herr' : 'Frau';
• $max = $a > $b ? $a : $b;

• Größere Abschnitte auskommentieren:

if (0) {
 ... nicht abgearbeiteter, aber interpretierter Kode - Syntax muss stimmen!
}

Schleifen

while (Bedingung) {        # Solange Bedingung wahr ist
   ...
}

until (Bedingung) {        # Solange Bedingung nicht wahr ist
   ...
}

do {
} while (Bedingung);

Auch hier bedingte Anweisungen:

• print "$i. Zeile\n" while (++$i <= 5);
• print lc($line) while $line = <STDIN>;

Zählschleife

for (Initialisierung; Abbruchbedingung; Operation) {
   ...
}

$guthaben = 1000;
for ($jahr = 1; $jahr <= 10; $jahr++) {
    $guthaben += $guthaben * 0.05;    # Zins 5 %
    printf "Jahr %2d: %8.2f\n", $jahr, $guthaben;  # runden
}

Schleife über eine Liste: foreach $var (liste) { ... }

foreach $stadt ('Leipzig', 'Dresden', 'Chemnitz') {
    print "$stadt\n";
}

Sprungbefehle

• Verlassen des Programmes: exit wert;, mit Fehlermeldung: die "Fehler bei ...";
• Vorzeitiges Ausspringen aus einer Schleife: last (break in C)
• Springen zur Schleifenbedingung: next (continue in C)
• labels, goto ...

# Listet Dateien im aktuellen Verzeichnis mit Größe
foreach $file (<*>) {       # file globbing liefert Datei-Liste lt. Shell-Muster: *, ?, []
    next if (! -f $file);   # überspringen, wenn keine normale Datei
    $size = -s $file;
    print "$file\t$size\n"; 
}
# Das Ganze sehr kompakt - die Standardvariable $_ kommt ins Spiel
foreach (<*>) { -f && print "$_\t", -s, "\n"; }

Variablen (2)

Arrays

Initialisierung:

• @array = liste
liste = ( wert1, wert2, ... );
  • @wtage = ('Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So');
@wtage = qw(Mo Di Mi Do Fr Sa So); # identisch, qw = quoted words
  • @ziffern = (0 .. 9); # Bereichsoperator ..
  • @zeiten = split(':', '12:34:56');
($stunde, $minute, $sekunde) = split(':', '12:34:56');
  • zweidimensional: $matrix = ( ['00', '01'], ['10', '11']);

Zugriff:

• $array[index] - index von 0 bis $#array
  • $stunde = $zeiten[0];
  • print "Die Woche geht von $wtage[0] bis $wtage[$#wtage].\n";
  • print "Es gibt " . ($#wtage + 1) . " Wochentage.\n";
  • @wochenende = @wtage[5,6];
  • $wert = $matrix[1][0];

Funktionen:

• pop - entfernt das letzte Element und liefert es
• push - fügt ein oder mehrere Element(e) "hinten" an
• shift - entfernt das erste Element und liefert es
• unshift - fügt ein oder mehrere Element(e) "vorn" an
• splice - komplexe Operationen im Array

Beispiel: Argumente der Kommandozeile via @ARGV

$usage = "$0 datei1 datei2 ...";

if ($#ARGV <= 1) {
    die "Aufruf: $usage\n";
}
while (@ARGV) {    # alle Argumente
   $datei = shift @ARGV;
   # ...
}

• Array in Zeichenkette wandeln: print join(' | ', @wtage), "\n";
• vorher alphabetisch sortieren: print join(' | ', sort @wtage), "\n";
• oder umkehren: print join(' | ', reverse @wtage), "\n";
• Suchen: @mtage = grep(/M/, @wtage);

Hashes - Assoziativfelder

• %hash = (key => value, ... )
  • %telefon = ('Meier' => '1234', 'Mueller' => '5678');
  • Kopieren: %telefon_neu = %telefon;
  • Mehrfach-Hashes:

          %telefon2 = ('Meier' =>   { 'work' => '1234', 'home' => '4321'},
                       'Mueller' => { 'work' => '1234', 'home' => '4321'}
                      );

Zugriff:

• $hash{key}
  • print $telefon{'Mueller'}, "\n";
  • $dienst = $telefon2{'Meier'}{'work'};
  • Neuer Wert: $telefon{'Meier'} = '4321';
  • Neues Element: $telefon{'Schulze'} = '9876';
  • Element löschen: delete $telefon{'Mueller'};

Funktionen:

• if (! defined $telefon{'Chef'}) { $telefon{'Chef'} = '1000'; }
• keys %hash liefert Liste aller Schlüssel
• values %hash liefert Liste aller Werte

Beispiel: Gib kompletten Hash aus:

foreach $name (keys %telefon) {
    print "Name: $name\tTelefon: $telefon{$name}\n";
}
# Besser: sortiert, mit Überschrift
print "Name\tTelefon\n";
foreach $name (sort keys %telefon) {
    print "$name\t$telefon{$name}\n";
}
# Jetzt: Sortiert nach Wert
print "Telefon\tName\n";
foreach $name (sort {$telefon{$a} cmp  $telefon{$b}} keys %telefon) {
                                # cmp ist alphabetischer Vergleichsoperator
                                # <=> ist numerischer Vergleichsoperator
    print "$telefon{$name}\t$name\n";
}

Zugriff auf Umgebungsvariablen via %ENV

$home = $ENV{'HOME'};        # Lesen
$ENV{'PATH'} .= ':.';        # Setzen

Referenzen (Zeiger)

• Erzeugen:

$zeiger_s = \$s;
$zeiger_a = \@array; 
$zeiger_h = \%hash;
$zeiger_f = \&funktion;

• Zeiger bleiben gültig, auch wenn die ursprüngliche Variable nicht mehr existiert.

• Zugriff:

if ($$zeiger_s < 0) ...           # auch ${$zeiger_s}

@kopie = @$zeiger_a;              # Kopie des Arrays, auf das $zeiger_a zeigt
$first = $$zeiger_a[0];           # oder $zeiger_a->[0];
$last  = $$zeiger_a[$#$zeiger_a]; # oder $zeiger_a->[$#$zeiger_a];

$wert  = $$zeiger_h{'key'};       # oder $zeiger_h->{'key'};         

&$zeiger_f(1,2);                  # oder $zeiger_f->(1,2);

Umgang mit Dateien

Lesen

• Öffnen belegt "Dateizeiger", Konvention: Großbuchstabe(n):
  • open F, 'dateiname' - öffnet dateiname zum Lesen
  • open F, '/etc/passwd' or die "Fehler beim Oeffnen: $!\n";
    - Abfangen eines Fehlers, $! ist Systemfehlermeldung

• Lesen via Dateizeiger in "Diamantoperator":
  • $zeile = <F>; # eine Zeile
  • while ($zeile = <F>) { ... } # fuer jede Zeile
  • @inhalt = <F>; # gesamte Datei in Array, Zeilen indexierbar

# Datei ausgeben mit Zeilennummer:
print "Datei: ";
$datei = <STDIN>;  # Abfrage via Eingabe
chomp $datei;      # Newline am Ende wegschneiden
open F, $datei or die "Kann $datei nicht oeffnen: $!\n";
while (<F>) {
    # Ohne Variable --> verwende Standard-Variable $_
    print $., ' ', $_;       # $. = aktuelle Zeilennummer
}

while ($zeile = <>) {
    print lc($zeile);      # alles in Kleinbuchstaben wandeln und ausgeben.
}
# Kurzform
while (<>) {       # Standard-Variable $_ verwenden
    print lc;      # Auch lc verwendet Standard-Variable ...
}

# Neue Datei ausgeben mit Zeilennummern:
print "Datei: ";
$datei = <STDIN>;  # Abfrage via Eingabe
chomp $datei;      # Newline am Ende wegschneiden
open LIES, $datei or die "Kann $datei nicht oeffnen: $!\n";
open SCHREIB, "> $datei.num" or die "Kann $datei.num nicht zum Schreiben oeffnen: $!\n";
while (<LIES>) {
    print SCHREIB $., ' ', $_;       # $. = aktuelle Zeilennummer
}
close SCHREIB;
close LIES;
print "Datei $datei.num geschrieben.\n";

if (system("ls -l $dir") != 0) {
    print "Fehler bei Aufruf: $?\n";
}

# Transparentes Behandeln evtl. komprimierter Dateien
if ($datei =~ /\.gz$/) {   # dateiname mit .gz am Ende
    open F, "zcat $datei |" or die "Kann zcat nicht starten: $!\n";
} else {
    open F, $datei or die "Kann Datei nicht oeffnen: $!\n";
}
while (<F>) { ... }
close F;

# Mini-Taschenrechner
do {
    print "Rechner: ";
    chomp($in = <STDIN>);
    $res = eval $in;
    if ($@) {   # Fehler von eval
        print "Ungueltige Eingabe\n";
    } else {
        print "Ergebnis: $res\n";
    }
} while ($in);

sub summe2 {
    my ($a, $b) = @_;
    return $a + $b;    
}
sub summe {      # beliebige Anzahl der Argumente
    my $s = 0;
    foreach (@_) { $s += $_; }
    return $s;
}

print summe(1..1000), "\n";

@grossdatei = <F>;          # gesamte Datei in array
&work(\@grossdatei);

sub work {
    my ($aref) = $@;
    print $aref->[0]; ...
}

# Bei ^C soll eine temporäre Datei gelöscht werden, danach wird beendet.
$SIG{'INT'} = \&tmpdatei_loeschen;
...
sub tmpdatei_loeschen {
    unlink '/tmp/temp_datei';
    exit;
}

print "Abbruch? ";
chomp($eingabe = <STDIN>);
exit if ($eingabe =~ /j/);        # eingabe enthält j

if ($dateiname !~ m#/#) { ... }   # dateiname enthält KEIN /

while (<>) {
    print if (/Subject:/);        # aktuelle Zeile enthält Subject:
}

$htmltitel = '<title>Perl-Zauberei</title>';
$text = $text1 = $text2 = $htmltitel;
$text  =~ s/<.+>//;       # ersetze alles zwischen < und > durch nichts
$text1 =~ s/<.+?>//;      # das gleiche, nur "nicht gefräßig"
$text2 =~ s/<.+?>//g;     # das gleiche, nur "nicht gefräßig" und beliebig oft

print "$text\n$text1\n$text2\n";

# Palindrome mit vier Buchstaben, z.B. ANNA
if (open(F, '/usr/share/dict/words')) {
    while (<F>) {
        $l = lc;                              # Zeile in Kleinbuchstaben
        print if ($l =~ /^(\w)(\w)\2\1$/);    # zwei Zeichen, dann 2. Zeichen und wieder 1. Zeichen
    }
}

while (<>) {                 # Für jede Zeile 
     while (/(.+?)\s+/g) {   # mind. 1 beliebiges Zeichen bis Leerzeichen, 
                             # minimal matchen, merken, alle Vorkommen
         $c++;
     }
}
printf "$c %s\n", $c == 1 ? 'Wort' : 'Woerter';

# Klient      - user Datum       Zeit            Request                     Status Bytes
134.109.200.2 - fri [15/Jan/2008:13:55:36 +0100] "GET /apache_pb.gif HTTP/1.0" 200 2326

while (<>) {    # zeilenweise für alle Dateien der Kommandozeile
    #     Klient  user    Datum/Zeit      Dokument   Status Bytes
    if (/^(\S+) - (\S+) \[(\S+) .+\] "\S+ (\S+) \S+" (\d+) (\d+)/) {
        $bytes += $6;       # Bytes summieren
        $HOSTS{$1}++;       # Hostzugriff merken
    } else {
        print STDERR "Fehler: $_";
    }
}
# Auswertung:
print "Daten: $bytes Bytes\n\n";
# Sortieren: Welcher Klient hat am meisten geholt:
print "Zugriffe : Klient\n";
foreach $h (sort {$HOSTS{$b} <=> $HOSTS{$a}} keys %HOSTS) {
    printf "%8d : %s\n", $HOSTS{$h}, $h;
}

# Beispiel für Arbeit mit Umlauten im ISO-8859-1-Zeichensatz = Latin1

# seit perl 5.8: Daten sind Latin1, Bildschirmausgabe aber UTF-8-Zeichen
use encoding latin1, STDOUT => "utf8";

# Hier ISO-8859-1 kodiert:
$umlaute = 'Umlaute sind äöüÄÖÜ(ß)';

#      z.B. \w umfasst auch Umlaute
($entfernt = $umlaute) =~ s/\w+//g;

print "Normal: $umlaute" .
      "\nGross:  " . uc($umlaute) .
      "\nKlein:  " . lc($umlaute) .
      "\nEntfernt: .$entfernt.\n";

#!/usr/bin/perl
# Beispiel für Arbeit mit Umlauten: UTF-8 kodiert

use encoding 'utf8';     # seit Perl 5.8
# use utf8;              # nur nötig, wenn z.B. auch Variablennamen UTF-8 einhalten
use open ':utf8';        # zu öffnende Dateien enthalten UTF-8-Daten
  
# Hier UTF-8 kodiert:
$umlaute = 'Umlaute sind äöüÄÖÜ(ß)';

($entfernt = $umlaute) =~ s/\w+//g;     # \w umfasst auch UTF-8-Zeichen

print "Normal: $umlaute" .
      "\nGross:  " . uc($umläute) .
      "\nKlein:  " . lc($umläute) .
      "\nEntfernt: .$entfernt.\n";

use Getopt::Std;
# Aufruf:  perlskript [-d] [-o datei]
getopts('do:');         # -d ohne Argument, -o mit Argument

$debug = $opt_d;        # 1, wenn -d vorhanden
if ($opt_o) {           # Wenn -o vorhanden
    $output = $opt_o;   # verwende Wert
}
...

use Tk;
my $fenster = MainWindow->new;      # Hauptfenster erzeugen
$fenster->geometry('300x150');      # Größe

# Ein Knopf mit Aktion
$fenster->Button(-text => 'Hallo Welt!', -command => \&action)->pack();

# "Warteschleife"
MainLoop;

sub action { print "Hallo Du!\n"; exit; }

#!/usr/bin/perl
# erstes CGI-Skript - ohne CGI.pm

print "Content-Type: text/html\n\n";

print <<HTML;
<html><head><title>Mein erstes CGI-Skript</title></head>
<body>
<h1>Hallo Welt!</h1>
</body>
</html>
HTML

#!/usr/bin/perl
# CGI-Skript - mit CGI.pm

use CGI qw(:standard);
print header,
      start_html('CGI-Skript mit CGI.pm'),
      h1('Hallo Welt!'), end_html;

#!/usr/bin/perl
# CGI-Skript mit einfachem Formular und Auswertung

use CGI qw(:standard);
use HTML::Entities 'encode_entities';   # Kodierung von HTML-Sonderzeichen
print header,
      start_html('Englisches Wörterbuch'),
      h1('Englisches Wörterbuch'),
      start_form,
      'Gesuchtes Muster: ', input({'name'=>'frage'}),
      submit,
      end_form,
      hr;

if (param()) {      # Sind Werte übergeben worden? = Formular abgeschickt
    my $suchwort = param('frage');   # Zugriff auf formularwert
    if ($suchwort) {
        print 'Suche nach ', encode_entities($suchwort);
        print pre(suche($suchwort));        # schreibe Ergebnisse in <pre>
    }
}
print end_html;

sub suche {
    my ($wort) = @_;
    my $ergebnis = '';
    if (! open F, '/usr/share/dict/words') { 
        return "Kann Datei nicht &ouml;ffnen: $!\n";
    }
    while (<F>) {
        $ergebnis .= $_ if (/\Q$wort\E/);  # Sonderzeichen flüchten
    }
    close F;
    $ergebnis =~ s#$wort#<b>$wort</b>#g;   # Suchwort fett markieren: <b>...</b>
    return $ergebnis;
}

#!/usr/bin/perl
# Beispiel zum Zugang zu MySQL-Datenbanken

use DBI;
# DB-Verbindung          Typ  Datenbank  Server             Login Passwort
$dbh = DBI->connect('DBI:mysql:events:www-db.tu-chemnitz.de', '', '')
   or die "Kann Datenbank-Verbindung nicht herstellen: $DBI::errstr\n";

# Abfrage vorbereiten
my $sth = $dbh->prepare('SELECT * FROM event WHERE startdate >= NOW() ORDER BY startdate LIMIT 5');

if ($sth->execute) {              # Abfrage starten
    # DBI::dump_results($sth);    # Zum Test "rohe" Ausgabe

    while (my $ref = $sth->fetchrow_arrayref) {     # Ergebnisse "abholen"
        print " Titel: $$ref[1]\nBeginn: $$ref[4]\n\n";
    }
}

$dbh->disconnect();         # DB-Verbindung beenden