SELFHTML/Quickbar CGI/Perl Perl-Sprachelemente

| ## Operatoren
| Zuweisungsoperator Vergleichsoperatoren Berechnungsoperatoren Logische Operatoren Bit-Operatoren Operator zur Zeichenkettenverknüpfung Operator zur Zeichenkettenwiederholung Operatorenrangfolge

## Zuweisungsoperator

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

### Beispiele:

    $Name = "Josua Piesepampel";
    $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.

### Beispiele:

    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 Istgleichzeichen `==` 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, benutzen Sie den Vergleichsoperator `=~`.

## Berechnungsoperatoren

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

### Beispiele:

    $Hundertlasser = 83 + 17;
    $Hundertlasser = 113 - 13;
    $Hundertlasser = 4 * 25;
    $Hundertlasser = 450 / 4.5;
    $Hundertlasser = 450 / 2 - 125;
    $Hundertlasser = 10 * (2 + 8);
    $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 erniedridgen

### 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. Eine Besonderheit stellt der Operator `%` dar. Damit wird eine sogenannte 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 `$ImmerGleich = 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;`
`$Zahl -= 10;` ist eine Abkürzung für `$Zahl = $Zahl - 10;`

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

## Logische Operatoren

Logische Operatoren brauchen Sie, wenn Sie komplexere Bedingungen für bedingte Anweisungen oder Schleifen formulieren wollen.

### Beispiel:

    #!/usr/bin/perl

    $Versuche = 1;
    $Wert = 0;
    $min = 66;
    $max = 77;

    Eingabe:
    print "Geben Sie eine Zahl zwischen ", $min, " und ", $max, " ein: ";
    $Wert = <STDIN>;
    chop($Wert);
    if($Wert < $min || $Wert > $max)
     {
      if($Wert =~ /[^0-9]/)
       {
         print "Das war keine Zahl.\n\n";
         $Versuche++;
         goto Eingabe;
       }
      if($Versuche < 3 && $Wert < $min)
       { print "Ihre Zahl war zu klein.\n\n"; }
      elsif($Versuche < 3 && $Wert > $max)
       { print "Ihre Zahl war zu gross.\n\n"; }
      elsif($Versuche >= 3 && $Wert < $min)
       { print "Ihre Zahl war verdammt noch mal zu klein!\n\n"; }
      elsif($Versuche >= 3 && $Wert > $max)
       { print "Ihre Zahl war verdammt noch mal zu gross!\n\n"; }
      $min = abs($Wert - $min);
      $max = $min + abs($max - $min);
      $Versuche++;
      goto Eingabe;
     }
    if($Versuche > 1)
     { print "Sehen Sie, so lernt man dazu!\n"; }
    else
     { print "Sie waren sicher mal ein braves Kind!\n"; }

### Erläuterung:

Mit dem logischen Operator `&&` 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 `||` 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.

## Bit-Operatoren

Bit-Operatoren sind nur etwas für Profis. 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
`&` definiert in einer Bitmaske eine Und-Bedingung
`|` definiert in einer Bitmaske eine inklusive Oder-Bedingung
`^` definiert in einer Bitmaske eine exklusive Oder-Bedingung
`!` definiert in einer Bitmaske eine Negations-Bedingung
`~` definiert in einer Bitmaske eine Komplementär-Bedingung

## Operator zur Zeichenkettenverknüpfung

Mit einem Punkt . können Sie eine Zeichenkette an eine andere anhängen.

### Beispiel:

    #!/usr/bin/perl

    @Subjekte = ("Helmut Kohl ","Theo Waigel ","Rudolph Scharping ","Gerhard Schroeder ");
    @Praedikate = ("liebt ","verehrt ","umgarnt ","bereichert ");
    @AkkusativObj = ("den Zauber ","die Freuden ","das Prinzip ","den Rausch ");
    @GenitivObj = ("der Macht.","des Bundestags.","der neuen Bundeshauptstadt.","der Sinneslust.");
    @Indizes = (0..3);

    print "ZUFALLS"."SAETZE\n\n";
    while($i < 10)
     {
      $j = 0;
      sleep(2);
      $Zufallssatz = "";
      srand(time());
      foreach $j (0..3)
       {
        $Indizes[$j] = rand(3);
       }
      $Zufallssatz = $Zufallssatz.$Subjekte[$Indizes[0]];
      $Zufallssatz = $Zufallssatz.$Praedikate[$Indizes[1]];
      $Zufallssatz = $Zufallssatz.$AkkusativObj[$Indizes[2]];
      $Zufallssatz = $Zufallssatz.$GenitivObj[$Indizes[3]];
      print $Zufallssatz, "\n";
      $i++;
     }

### Erläuterung:

Sie können sowohl Zeichenkettenvariablen als auch direkte Zeichenkettenangaben mit `.` aneinanderhängen.

Das obige Beispiel-Script erzeugt Zufallssätze basierend auf den Listen von Satzelementen, die am Beginn des Scripts definiert werden.

## Operator zur Zeichenkettenwiederholung

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

### Beispiel:

    #!/usr/bin/perl

    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: `,` (Aneinanderreihung)
2. Rangstufe: `= += -= &= ^= |=` (Zuweisung)
3. Rangstufe: `?:` ( Entweder-Oder-Bedingung)
4. Rangstufe: `..` (Bereichsdefinition in Listen)
5. Rangstufe: `||` (logisches Oder)
6. Rangstufe: `&&` (logisches Und)
7. Rangstufe: `| ^` (bitweises Oder - inklusiv/exklusiv)
8. Rangstufe: `&` (bitweises Und)
9. Rangstufe: `== != eq ne` (Gleichheit/Ungleichheit)
10. Rangstufe: `< <= > >= lt le gt ge` (Vergleich größer/kleiner)
11. Rangstufe: `<< >> >>` (Verschieben von Bits)
12. Rangstufe: `+ - .` (Addition, Subtrakion, Zeichenkettenaddition)
13. Rangstufe: `* / % x` (Multiplikation, Division, Modulo-Division, Zeichenkettenwiederholung)
14. Rangstufe: `=~ !~` (Übereinstimmung bei regulären Ausdrücken)
15. Rangstufe: `**` (Potenzierung)
16. Rangstufe: `! ~ -` (Bitoperatoren)
17. Rangstufe: `++ --` (Inkrementieren, Dekrementieren)

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

### Beispiel:

    #!/usr/bin/perl

    $OffizielleStatistik = 3.29 * 3 + 4.71;
    $MeineStatistik = 3.29 * (3 + 4.71);
    print "Die offizielle Statistik sagt ",$OffizielleStatistik"\n"
    print "Meine Statistik sagt ",$MeineStatistik,"\n";

weiter: | Reguläre Ausdrücke
zurück: | Schleifen und Sprungbefehle

SELFHTML/Quickbar CGI/Perl Perl-Sprachelemente

© 1998 Stefan Münz, muenz@csi.com