# Operatoren

| Zuweisungsoperatoren Vergleichsoperatoren Berechnungsoperatoren Logische Operatoren Bit-Operatoren Operator für Zeichenkettenverknüpfung Operator für Zeichenkettenwiederholung Operatorenrangfolge

## Zuweisungsoperatoren

Sie können zum Beispiel einem Skalar einen Wert zuweisen. Der Zuweisungsoperator dafür ist ein Gleichheitszeichen.

### Beispiel:

    my $Name = "Josua Piesepampel";
    my $Code = 4711;

### Erläuterung:

Den Skalaren wird mit dem Zuweisungsoperator `=` jeweils ein Wert zugewiesen.

## Vergleichsoperatoren

Vergleichsoperatoren brauchen Sie, wenn Sie zwei Werte vergleichen wollen, z.B. den aktuellen Inhalt eines Skalars mit einem fixen Wert.

### Beispiel:

    if($SinnDesLebens == 42)
     { print "Sie haben das Leben verstanden!\n" };
    if($SinnDesLebens != 42)
     { print "Sie haben nix kapiert vom Leben!\n" };
    if($SinnDesLebens > 42)
     { print "Sind Sie wahnsinnig?\n" };
    if($SinnDesLebens < 42)
     { print "Sie sind eine Nummer zu klein für das Leben!\n" };
    if($Alter >= 18)
     { print "Sie dürfen selbst diesen Schwachsinn hier sehen!\n" };
    if($Alter <= 17)
     { print "Sie sind nicht mal alt genug für diesen Schwachsinn!\n" };

    if($Passwort eq "Hexasex")
     { print "Sie haben Zugang zum Sex im hexadezimalen Raum!\n" };
    if($Passwort ne "Hexasex")
     { print "Haben Sie lieber eindimensionalen Sex daheim im Bett!\n" };
    if($Name gt "Y")
     { print "Sie sind aber auch immer der Letzte!\n" };
    if($Name lt "B")
     { print "Sie sind aber auch immer der Erste!\n" };
    if($Name ge "ZZ Top")
     { print "Ihre Lieblingsband ist ZZ Top oder was ganz Perverses!\n" };
    if($Name le "Abba")
     { print "Ihre Lieblingsband ist Abba oder was ganz Perverses!\n" };

    if($Alter =~ /[^0-9]/)
     { print "Das ist ja gar keine Zahl!\n" };

### Erläuterung:

Perl unterscheidet Vergleichsoperatoren für Zahlen und für Zeichenketten. Ferner gibt es einen speziellen Operator für Vergleiche mit regulären Ausdrücken.

Um abzufragen, ob zwei Zahlen gleich sind, notieren Sie zwei Gleichheitszeichen `==` nebeneinander.
Um abzufragen, ob zwei Zahlen unterschiedlich sind, notieren Sie zwischen beiden Werten die Zeichen `!=`.
Um abzufragen, ob eine Zahl größer oder gleich ist als eine andere, notieren Sie die Zeichen `>=`.
Um abzufragen, ob eine Zahl in jedem Fall größer ist als eine andere, notieren Sie das Zeichen `>`.
Um abzufragen, ob eine Zahl kleiner oder gleich ist als eine andere, notieren Sie die Zeichen `<=`.
Um abzufragen, ob eine Zahl in jedem Fall kleiner ist als eine andere, notieren Sie das Zeichen `<`.

Um abzufragen, ob zwei Zeichenketten gleich sind, notieren Sie `eq` zwischen den beiden Werten, die verglichen werden sollen (eq = equal = gleich).
Um abzufragen, ob zwei Zeichenketten unterschiedlich sind, notieren Sie `ne` zwischen den beiden Werten, die verglichen werden sollen (ne = not equal = nicht gleich).
Um abzufragen, ob eine erste Zeichenkette alphabetisch weiter hinten liegt als eine zweite, notieren Sie `gt` zwischen den beiden Werten, die verglichen werden sollen (gt = greater than = größer als).
Um abzufragen, ob eine erste Zeichenkette alphabetisch weiter vorne liegt als eine zweite, notieren Sie `lt` zwischen den beiden Werten, die verglichen werden sollen (lt = less than = kleiner als).
Um abzufragen, ob eine erste Zeichenkette alphabetisch gleich ist wie eine zweite oder weiter hinten liegt, notieren Sie `ge` zwischen den beiden Werten, die verglichen werden sollen (ge = greater or equal = größer oder gleich).
Um abzufragen, ob eine erste Zeichenkette alphabetisch gleich ist wie eine zweite oder weiter vorne liegt, notieren Sie `le` zwischen den beiden Werten, die verglichen werden sollen (le = less or equal = kleiner oder gleich).

Um den Wert eines Skalars, egal ob Zahl oder Zeichenkette, mit einem regulären Ausdruck zu vergleichen (Fachjargon: an einen regulären Ausdruck zu binden), benutzen Sie den Bindungsoperator `=~`.

## Berechnungsoperatoren

Um mit numerischen Werten Berechnungen durchzuführen, brauchen Sie Berechnungsoperatoren.

### Beispiel:

    $Hundertlasser = 83 + 17;
    $Hundertlasser = 113 - 13;
    $Hundertlasser = 4 * 25;
    $Hundertlasser = 450 / 4.5;
    $Hundertlasser = 450 / 2 - 125;
    $Hundertlasser = 10 * (2 + 8);
    $Hundertlasser = 10 ** 2;
    $x = $Hundertlasser % 4;
    if($x == 0)
     { print $Hundertlasser, " ist ein Schaltjahr\n" }

    # Besondere Notationen:

    $Zahl = 100;
    $Zahl++;      # $Zahl um 1 erhoehen
    $Zahl--;      # $Zahl um 1 erniedrigen
    $Zahl += 10;  # $Zahl um 10 erhoehen
    $Zahl -= 10;  # $Zahl um 10 erniedrigen
    $Zahl *= 10;  # $Zahl mit 10 multiplizieren
    $Zahl /= 10;  # $Zahl durch 10 dividieren
    $Zahl %= 10;  # $Zahl durch 10 modulo-dividieren
    $Zahl **= 2;  # $Zahl hoch 2 errechnen

### Erläuterung:

Mathematische Operatoren notieren Sie mit den dafür üblichen Zeichen. Mit `+` notieren Sie eine Addition, mit `-` eine Subtraktion, mit `*` eine Multiplikation, mit `/` eine Division, und mit `**` eine Potenzoperation "x hoch y". Eine Besonderheit stellt der Operator `%` dar. Damit wird eine so genannte Modulo-Division durchgeführt. Bei einer Modulo-Division werden zwei Werte dividiert. Das Ergebnis ist jedoch im Gegensatz zur normalen Division nur der Restwert der Division. Wenn Sie z.B. `13 % 5` notieren, erhalten Sie als Ergebnis 3, weil 13 geteilt durch 5 gleich 2 Rest 3 ergibt. Diese 3 ist es, die als Ergebnis einer Modulo-Division herauskommt.

Sie können mehrere Operationen in Reihe notieren. Dabei gilt die übliche "Punkt-vor-Strich-Regel". Wenn Sie eine andere Regel erzwingen wollen, müssen Sie Klammern verwenden, so wie im obigen Beispiel `$Hundertlasser = 10 * (2 + 8);`.

Die besonderen Notationen, die in den obigen Beispielen vorkommen, können Sie verwenden, wenn Sie Additionen oder Subtraktionen abkürzen wollen:
`$Zahl++;` ist eine Abkürzung für `$Zahl = $Zahl + 1;`
`$Zahl--;` ist eine Abkürzung für `$Zahl = $Zahl - 1;`
`$Zahl += 10;` ist eine Abkürzung für `$Zahl = $Zahl + 10;`
usw. bei den gleichartigen Operationen.

Der Operator `++` wird auch als Inkrementationsoperator bezeichnet, der Operator `--` als Dekrementationsoperator.

### Beachten Sie:

Bei den Operatoren `++` und `--` gibt es eine Besonderheit, die auf C bzw. sogar auf die Maschinensprache (Assembler) zurückzuführen ist. Die Operatoren können sowohl vor als auch nach der Variablen notiert werden (also z.B. sowohl `$Zahl++` als auch `++$Zahl`). Werden sie davor notiert, wird die Operation ausgeführt, bevor der Ausdruck ausgewertet wird (Fachjargon: Pre-In-/Dekrement). Umgekehrt gilt: wird der Operator nach der Variablen notiert, wird die Operation ausgeführt, nachdem der Ausdruck ausgewertet wurde (Fachjargon: Post-In-/Dekrement). Die Ausgabe des folgenden Codes sollte Sie also nicht überraschen:
`my $Zahl=1;
print $Zahl++;
print --$Zahl;`
Es wird zweimal `1` ausgegeben. Beim erstenmal, weil `$Zahl` ausgegeben wird, bevor Eins dazuaddiert wird. Beim zweitenmal, weil Eins subtrahiert wird, bevor `$Zahl` ausgegeben wird.

## Logische Operatoren

Logische Operatoren brauchen Sie, um Ausdrücke zu formulieren, die wahr oder falsch sein können. Verwendung finden solche Ausdrücke besonders in Bedingungen für bedingte Anweisungen oder Schleifen.

### Beispiel:

    if($a == 1 && $b == 2) {
      # wenn a = 1 ist und b = 2
    }
    if($a == 1 and $b == 2) {
      # wenn a = 1 ist und b = 2
    }
    if($a == 1 || $b == 1) {
      # wenn a = 1 oder b = 1 ist
    }
    if($a == 1 or $b == 1) {
      # wenn a = 1 oder b = 1 ist
    }
    if($a == 1 ^ $b == 1) {
      # wenn entweder a = 1 oder b = 1 ist
    }
    if($a == 1 xor $b == 1) {
      # wenn entweder a = 1 oder b = 1 ist
    }
    if (! ($a == 2)) {
      # nicht a = 2
    }
    if (not ($a == 2)) {
      # nicht a = 2
    }

### Erläuterung:

Mit dem logischen Operator `&&` oder dem Wort dafür (`and`) verknüpfen Sie zwei oder mehrere Bedingungen durch "und", d.h. beide bzw. alle Bedingungen müssen erfüllt sein, damit die gesamte Bedingung erfüllt ist.
Mit dem logischen Operator `||` oder dem Wort dafür (`or`) verknüpfen Sie zwei oder mehrere Bedingungen inklusiv durch "oder", d.h. es genügt, wenn eine der Bedingungen erfüllt ist, damit die gesamte Bedingung erfüllt ist.
Mit dem logischen Operator `^` oder dem Wortkürzel dafür (`xor`) verknüpfen Sie zwei oder mehrere Bedingungen exklusiv durch "oder", d.h. es muss entweder die eine oder die andere Bedingungen erfüllt sein, damit die gesamte Bedingung erfüllt ist.
Mit dem logischen Operator `!` oder dem Wortkürzel dafür (`not`) verneinen Sie eine nachfolgende Bedingung, d.h. Sie fragen nicht, ob die Bedingung wahr ist, sondern ob sie falsch ist.

## Bit-Operatoren

Um Bit-Operatoren richtig einzusetzen, müssen Sie viel von computer-internen Speichervorgängen verstehen. Deshalb werden die Bit-Operatoren hier nur kurz erwähnt.

`>>` verschiebt Bits nach rechts
`<<` verschiebt Bits nach links
`&` verknüpft zwei Werte mit einem bitweisen UND
`|` verknüpft zwei Werte mit einem bitweisen ODER
`^` verknüpft zwei Werte mit einem bitweisen Exlusiv-Oder (XOR)
`~` bildet das Komplement eines Wertes (alle Bits kehren sich um)

## Operator für Zeichenkettenverknüpfung

In Perl brauchen Sie nicht wie in manchen anderen Programmiersprachen eine Funktion, um Zeichenketten zu verknüpfen, sondern es gibt einen Operator dafür.

### Beispiel eines vollständigen CGI-Scripts in Perl:

Anzeigebeispiel: So sieht's aus (Zum Aufruf des Scripts ist eine Internet-Verbindung erforderlich)

    #!/usr/bin/perl -w

    use strict;
    use CGI::Carp qw(fatalsToBrowser);

    my $HTML_Ausgabe = "Die Umgebungsvariable <b>HTTP_USER_AGENT</b> hat den Wert <b>".$ENV{HTTP_USER_AGENT}."</b><br>";
    $HTML_Ausgabe .= "<hr>Ende der Ausgabe";

    print "Content-type: text/html\n\n";
    print '<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">', "\n";
    print "<html><head><title>Testausgabe</title>\n";
    print "</head><body>\n";

    print $HTML_Ausgabe;

    print "</body></html>\n";

### Erläuterung:

Ein Punkt `.` ist der Operator, um Zeichenketten miteinander zu verknüpfen. Die verknüpften Zeichenketten können literal sein, also einfach Text enthalten, aber auch eine Variable sein. Im Beispiel-Script sehen Sie einen für CGI-Scripts typischen Anwendungsfall für den Zeichenkettenoperator. Dort wird eine längere HTML-Ausgabe, gespeichert im Skalar `$HTML_Ausgabe`, aus einzelnen Zeichenketten zusammengebastelt. Unter anderem wird dabei der Wert der Umgebungsvariablen `HTTP_USER_AGENT`, die Namen und Version des aufrufenden Browsers enthält, mit eingefügt.

Das Beispiel-Script zeigt in der zweiten Anweisung auch, wie sich neue Zeichenketten an eine bereits vorhandene anhängen lassen. Mit `.=` wird das, was rechts davon steht, einfach der Variablen zugewiesen, die links davon steht. Die gleiche Anweisung könnten Sie übrigens auch in folgender Langform notieren:
`$HTML_Ausgabe = $HTML_Ausgabe."<hr>Ende der Ausgabe";`

Das Script gibt die zusammengesetzte Zeichenkette mit einer `print`-Anweisung aus.

## Operator für Zeichenkettenwiederholung

In Perl können Sie mit `x` Zeichenketten "multiplizieren".

### Beispiel:

    print "A"."h" x 10, "!\n";
    # erzeugt die Ausgabe "Ahhhhhhhhhh!"

### Erläuterung:

Notieren Sie den `x`-Operator hinter der Zeichenkette, die Sie multiplizieren wollen. Hinter dem Operator geben Sie an, wie oft die Zeichenkette wiederholt werden soll.

## Operatorenrangfolge

Unter den Operatoren von Perl gibt es eine festgelegte Rangordnung. Wenn Sie komplexe Rechenoperationen durchführen oder mehrere Bedingungen miteinander verknüpfen, gilt bei der internen Auflösung solcher komplexen Ausdrücke die folgende Rangordnung:

1. Rangstufe: `++ --` (Inkrementieren, Dekrementieren)
2. Rangstufe: `**` (Potenzierung)
3. Rangstufe: `! ~` (logische und bitweise Negation)
4. Rangstufe: `=~ !~` (Bindung an reguläre Ausdrücke)
5. Rangstufe: `* / % x` (Multiplikation, Division, Modulo-Operation, Zeichenkettenwiederholung)
6. Rangstufe: `+ - .` (Addition, Subtraktion, Zeichenkettenaddition)
7. Rangstufe: `<< >>` (Verschieben von Bits)
8. Rangstufe: `< <= > >= lt le gt ge` (Vergleich größer/kleiner)
9. Rangstufe: `== != eq ne` (Gleichheit/Ungleichheit)
10. Rangstufe: `&` (bitweises UND)
11. Rangstufe: `| ^` (bitweises ODER - inklusiv/exklusiv)
12. Rangstufe: `&&` (logisches UND)
13. Rangstufe: `||` (logisches ODER)
14. Rangstufe: `..` (Bereichsdefinition in Listen)
15. Rangstufe: `?:` ( Entweder-Oder-Bedingung)
16. Rangstufe: `= += -= &= ^= |=` (Zuweisung)
17. Rangstufe: `, =>` (Aneinanderreihung)
18. Rangstufe: `not` (logische Negation)
19. Rangstufe: `and` (logisches UND)
20. Rangstufe: `or xor` (logisches ODER (inklusiv/exklusiv)

Mit Hilfe von Klammern können Sie die Rangfolge bei den Operatoren beeinflussen und Ausdrücke so bewerten, wie Sie es wünschen.

### Beispiel:

    $OffizielleStatistik = 3.29 * 3 + 4.71;
    $MeineStatistik = 3.29 * (3 + 4.71);

### Erläuterung:

Durch die Klammer wird in dem Beispiel die "Punkt-vor-Strich"-Regel, die auch unter den Berechnungsoperatoren von Perl gilt, aufgehoben.

| Reguläre Ausdrücke
| Sprungbefehle

© 2007 Impressum