Perl - Reference

# PERL = Practical Extraction and Report Language
# Comprehensive Perl Archive Network – CPAN (http://www.cpan.org)
    # Perl Interpret downloadbar unter:
        # http://wwww.perl.com
        # http://www.activestate.com/pw32
 
    # Perl-Script ausführen:
        # perl scriptname -d      ... Debugger
        # perl scriptname -w      ... Warnungen (deaktivierbar)
        # perl scriptname -W      ... Warnungen fest aktiviert
        # perl scriptname -X      ... Warnungen fest deaktiviert
        # perl scriptname -c      ... Syntaxanalyse
 
 
# Hello-World Beispiel:
    #! user/bin/perl                # Pfadangabe des Interpreters
    print "Hello world! \n";        # \r ... Carriage Return (Zeilenvorschub)
                                    # \n ... Line Feed
                                    # \a ... Alarm
                                    # \t ... Tabulator
                                    # \b ... Backspace
                                    # \e ... Escape
                                    # \f ... Formfeed (Seitenvorschub)
 
 
# Datentypen
    # Skalare (Zahl, Text, Referenz)
        $a = 0;
        $a = 0xff;
        $b = "text";
        $b = 'text';
        $c = $a . "text" . $b;
 
 
    # Arrays (Indizierbare Liste skalarer Werte)
        @d = ("one", "two", $b, "text");
                                    # d[0] ... one
                                    # d[1] ... two
                                    # d[2] ... text
                                    # d[3] ... text
 
        $tmp = $d[0];               # erstet Element
        $tmp = $d[-1];              # letztes Element
        push(@d, "three");          # Element/e am Ende hinzufügen
        push(@c, "four", @d);
        $tmp = pop(@d);             # letztes Element entfernen u. zurückgeben
        delete(@d[0]);              # Element löschen
        delete(@d[0, 2]);
 
        $tmp = @d;                  # tmp  ... onetwotexttext
        $tmp = join(":", @d);       # tmp  ... one:two:text:text
        @d = split(/:/, $tmp);      # Aufteilen und in ein Array speichern
 
        sort @d;                    # nach Alphabet sortieren
        reverse @d;                 # Elemente umkehren
 
        $nr = scalar @d;            # Anzahl der Array-Elemente
        $nr = $#d + 1;              # Index des letzten Elements
 
    # Hashes (Assoziatives Array skalarer Werte)
        %address = ("name" => "muster1",
                    "street" => "muster2",
                    "town" => "muster3",
                    "state" => "muster4"
                   );
 
        $tmp = $address{"name"};    # Rückgabe des Wertes mit bestimmten Key
        $address{"door"} = "2";     # Element hinzufügen
        delete($address{"town"});   # Key und Wert löschen
        delete($address{"town", "state"});
 
        @tmp = keys %address;       # Erhalt sämtlicher Keys
        @tmp = values %address;     # Erhalt sämtlicher Werte
        if (exists($address{"name"}))
        { ... }                     # Abfrage ob Element vorhanden ist
 
    # spezial Variablen
        $_                          # standardmäßige Eingabe-, Ausgaberaum
                                    # (aktuelles Element innerhalb von
                                    # Schleifen)
        $/                          # Trennzeichen für Eingaberecords
                                    # (defaultmäßig: Newline-Zeichen)
        $\                          # Trennzeichen für Ausgaberecords
                                    # (defaultmäßig: Leerstring)
        $0                          # Name des Skripts
        $^O                         # Name des Betriebssystems
 
        @ARGV                       # Array mit den Kommandozeilen-Parametern
        @INC                        # Verzeichnis-Liste, wo nach Perl-Scripten
                                    # gesucht wird
 
        %ENV                        # Umgebungsvariablen
 
    # Referenzen
        $ref = \$var;               # Referenz von einem Skalar $var
        $$ref                       # der von $ref referenzierte Skalar
 
        $ref = \@var;               # Referenz von einem Array
        $$ref[0]                    # Dereferenzierung einer Array-Referenz
        $ref->[0]
 
        $ref = \%var;               # Referenz von einem Hash
        $$ref{"key"}                # Dereferenzierung einer Hash-Referenz
        $ref->{"key"}
 
        $ref = \&mysub;             # Referenz einer Funktion
        &$ref();                    # Aufruf der Funktion
        $ref->();
 
        $isRef = ref($var);         # Überprüft ob Variable Referenz ist
 
 
# Operatoren
    # Arithmetisch
        $x = $y + $z;               # Addition
        $x += $y;
        $x = $y - $z;               # Subtraktion
        $x = $y * $z;               # Multiplikation
        $x = $y / $z;               # Division
        $x = $y % $z;               # Modulo
        $x = $y ** $z;              # Exponentierung
 
        $x = $y . $z;               # Zusammenführung
        $x = $y x $z;               # Wiederholung, $y wird $z mal wiederholt
 
    # Numerisch
        ==          eq              # gleich
        !=          ne              # ungleich
        <           lt              # kleiner
        <=          le              # kleiner gleich
        >           gt              # größer
        >=          ge              # größer gleich
        <=>         cmp             # Vergleich
 
    # Logisch
        $x && $y    $x and $y       # Und
        $x || $y    $x or  $y       # Oder
                    $x xor $y       # Exklusiv-Oder
        !$x            not $x       # Negation
 
    # Bitoperationen
        $x & $y                     # Und
        $x | $y                     # Oder
        $x ^ $y                     # Exklusiv-Oder
        ~$x                         # Komplement
        $x<<1                       # Links-Shift
        $x>>1                       # Rechts-Shift
 
 
# Schleifen
    # foreach
        foreach $skalar (@array)
        { ... }
 
        foreach $skalar (keys %hash)
        { ... }
 
        # der Schleifenrumpf wird für jedes Element des Arrays ausgeführt
        # das aktuelle Element wird dem $skalar übergeben
        # wenn @array leer ist, wird der Anweisungsblock nie ausgeführt
 
    # for
        for ($i=0, $i<10, $i++)
        { ... }
 
        $i=0    # links  ... Startanweisung
        $i<10   # mitte  ... Bedingung
        $i++    # rechts ... Auszuführende Anweisung nach einem Durchlauf
 
        # wird solange ausgeführt, solange die Bediengung erfüllt ist
 
    # if-else
        if ($bedingung1)
        { ...
        }
        elsif ($bedingung2)
        { ...
        }
        else
        { ...
        }
 
        if      # wenn die $bedingung1 erfüllt ist,
                # wird der zugehörige Anweisungsblock ausgeführt
        elsif   # wird nur überprüft, wenn vorherige Bedingungen nicht erfüllt
                # wurden (vorangestellte if/elsif)
        else    # wird ausgeführt wenn sämtliche vorherigen Bedingungen nicht
                # erfüllt wurden
 
    # while und unless
        while ($bedingung)
        { ...
        }
 
        do
        { ...
        }
        while ($bedingung)
 
        # solange die Bedingung erfüllt ist,
        # wird der Anweisungsblock ausgeführt
 
    # until
        until ($bedingung)
        { ...
        }
 
        do
        { ...
        }
        until ($bedingung);
 
        # bis die Bedingung erfüllt wird,
        # wird der Anweisungsblock ausgeführt
 
 
# Funktionen
    sub functionName
    {
        @_                          # Array mit übergebenen Parametern
        $_[0]                       # erster Parameter
        $_[1]                       # zweiter Parameter
        ...
    }
 
    functionName;                   # Aufruf der Subroutine
    functionName($parameter);       # Aufruf mit Übergabe
 
    # vordefinierte Funktionen
        chr($var)                   # Rückgabe des Zeichens welches durch
                                    # Dezimalzahl repräsentiert wird
        hex($var)                   # Wert interpretiert als Hexadezimalstring
        oct($var)                   # Wert interpretiert als Oktalstring
        ord($var)                   # numerische Werte des ersten Zeichens
 
        abs($var)                   # Absolutwert
        int($var)                   # ganzzahliger Teil
 
        sqrt($var)                  # Quadratwurzel
        exp($var)                   # e^$var
        log($var)                   # natürliche Logarithmus (Basis e)
 
        sin($var)                   # Sinus (Bogenmaß)
        cos($var)                   # Cosinus
        atan2($y, $x)               # Arkus-Tangens
 
        srand($time)                # Initialisierung des Zufallszahlen-
                                    # generators
        rand($var)                  # Zufallszahl zwischen 0 und $var
 
        time                        # Anzahl Sekunden seit Beginn der Epoche
        @time = localtime(time)     # Zeit
                                    # Index Beschreibung
                                    # 0     Sekunden
                                    # 1     Minuten
                                    # 2     Stunden
                                    # 3     Tag des Monats
                                    # 4     Monat (Jänner = 0)
                                    # 5     Jahre seit 1900
                                    # 6     Wochentag (Sonntag = 0)
                                    # 7     Jahrestag (1. Jänner = 0)
                                    # 8     Sommerzeit (SZ = True, WZ = False)
        ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) = @time;
 
 
# Filehandling
    # Datei öffnen
        open(FH, "test.txt");       # zum Lesen
        open(FH, "<$file");         # zum Lesen
        open(FH, ">$file");         # zum Schreiben (Datei überschreiben)
        open(FH, ">>$file");        # zum Schreiben (an Datei anhängen)
 
        open(FH, ">$file") || die("file not found");
 
        open(FH, "<:bytes", "test.bin");
                                    # :bytes            8-Bit-Bytes
                                    # :encoding(UTF-8)  wählt Codierung
                                    # :raw              Low-Level-E/A
 
        # FD ist ein Filehandle (STDIN, STDOUT, STDERR vordefiniert)
 
    # Datei schliesen
        close(FH);
 
    # Datei lesen und schreiben
        $char = getc(FH);           # Zeichen lesen
        $readChars = read(FH, $chars, $length, $offset);
        $line = <FH>;               # Zeile lesen
        $line = readline(FH);
        @allLines = <FH>;           # sämtliche Zeilen lesen
 
        print FH "text";            # in Datei schreiben
 
        eof(FH);                    # TRUE wenn am Ende oder nicht geöffnet
 
    # Dateitestoperationen
        if (-e "test.txt")          # -e ... ob Datei existiert
        { ...
        }
                                    # -r ... lesbar
                                    # -w ... schreibbar
                                    # -x ... ausführbar
 
                                    # -z ... Datei hat 0 Bytes
                                    # -s ... existiert und Größe ungleich 0
 
                                    # -f ... "normale" Datei
                                    # -d ... Ordner
                                    # -T ... Datei enthält ASCII Text
                                    # -B ... Binärdatei
 
    # Operationen für Verzeichnisse
        opendir(FH, "C:\\");
        closedir(FH);
 
        $entry = readdir(FH);       # nächster Verzeichnis-Eintrag
                                    # undef, wenn am Ende angelangt
        $entries = readdir(FH);     # sämtliche Verzeichnis-Einträge
 
    # weitere Operationen
        chmod                       # Datei-Rechte ändern
        chown                       # Datei-Besitzer ändern
        rename                      # umbennen
        unlink                      # löschen
        stat                        # zusätzliche Informationen
        chdir                       # Arbeitsverzeichnis wechseln
        mkdir                       # Verzeichnis anlegen
        rmdir                       # Verzeichnis löschen (nur wenn leer)
 
 
# Aufteilung von Projekten
    # Library
        # config.pl                 # abgelegt in "~/libs"
            my $confVal1 = 10;      # lokale Variable
            our $confVal2 = "test"; # globale Variable
            1;
 
        # basesubs.pl               # abgelegt in "~/libs"
            print "basesubs";
 
            sub sub1
            {
                print "basesubs-sub1";
            }
            1;
 
        # projectsubs.pl            # abgelegt im Projekt-Ordner
            package Project;        # Angabe eines Namensraumes
            print "projectsubs";
 
            sub sub2
            {
                print "projectsubs-sub2";
            }
 
            sub sub3
            {
                print "projectsubs-sub3";
            }
            1;
 
        # useall.pl                 # abgelegt im Projekt-Ordner
            print "main 1";
            push(@INC, "~/libs");   # Suchpfad ergänzen
            require "config.pl";
            require "basesubs.pl";
            require "projectsubs.pl";
 
            print "main 2";
            $tmp = $confVal2;
            sub1();
            Project::sub2();
            sub3();
            print "main 3";
                                    # Ausgabe:
                                    #       main 1
                                    #       basesubs
                                    #       projectsubs
                                    #       main 2
                                    #       basesubs-sub1
                                    #       projectsubs-sub2
                                    #       projectsubs-sub3
                                    #       main 3
 
    # Modul
        # Module.pm                 # abgelegt in "~/lib"
            package Special::Module;
            $Special::Module::VERSION = 0.1;
            use Exporter;
            @ISA = ("Exporter");
            our @EXPORT = ("sub2");
            print "Module";
 
            sub sub1
            {
                print "Module-sub1";
            }
            sub sub2
            {
                print "Module-sub2";
            }
            1
 
        # useall.pl                 # abgelegt im Projekt-Ordner
            print "main 1";
            use lib '~/lib';        # Suchpfad ergänzen
            use Special::Module;    # gleichwertig mit:
                                    #       require "Special/Module.pm"
                                    #       import default symbols
 
            print "main 2";
            Special::Module::sub1();
            sub2();
            print "main 3";
                                    # Ausgabe:
                                    #       Module
                                    #       main 1
                                    #       main 2
                                    #       Module-sub1
                                    #       Module-sub2
                                    #       main 3
 
 
# weitere Operationen
    exec                            # führt Befehl aus und kehrt nicht zurück
    system                          # führt Befehl in einem Child-Prozess aus,
                                    # und wartet auf dessen Ende
    sleep                           # Pause für x Sekunden