SELFHTML: JavaScript / Sprachelemente / Operatoren
Author: Redaktion SELFHTML, selfhtml81@selfhtml.org
Description: Welche Operatoren es in JavaScript gibt, und welche Aufgaben sie haben.
Keywords: SELFHTML, JavaScript, Operatoren, Berechnungsoperatoren, Zeichenkettenverknüpfung, logische Operatoren, Zuweisungsoperator, Vergleichsoperatoren, Bit-Operatoren, Operatorenrangfolge
Date: 2005-08-22T21:21:39+02:00

| # Operatoren
| Zuweisungsoperator Vergleichsoperatoren Berechnungsoperatoren Logische Operatoren Bit-Operatoren Operator zur Zeichenkettenverknüpfung Operatorenrangfolge Operator zur Typenbestimmung void-Operator Operator zum Löschen von Objekten

## Zuweisungsoperator

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

### Beispiel:

    <script type="text/javascript">
    var SinnDesLebens = 42;
    </script>

### Erläuterung:

Im Beispiel wird eine Variable namens `SinnDesLebens` definiert. Der Variablen wird mit dem Zuweisungsoperator `=` der Wert `42` zugewiesen.

## Vergleichsoperatoren

Vergleichsoperatoren brauchen Sie, wenn Sie zwei Werte vergleichen wollen, z.B. den aktuellen Inhalt einer Variablen mit einem fixen Wert. Vor allem bei bedingten Anweisungen und Schleifen kommt das vor.

### Beispiel:

    <script type="text/javascript">
    var SinnDesLebens = 42;
    var Alter = 8;

    if (SinnDesLebens == 42)
      alert(1);
    if (SinnDesLebens != 42)
      alert(0);
    if (SinnDesLebens > 42)
      alert(0);
    if (SinnDesLebens < 42)
      alert(0);
    if (Alter >= 18)
      alert("SIE duerfen das hier sehen!");
    if (Alter <= 17)
      alert("SIE duerfen das hier NICHT sehen!");
    </script>

### Erläuterung:

Um abzufragen, ob zwei Werte gleich sind, notieren Sie zwei Istgleichzeichen `==` nebeneinander.
Um abzufragen, ob zwei Werte unterschiedlich sind, notieren Sie zwischen beiden Werten die Zeichen `!=`.
Um abzufragen, ob ein Wert größer oder gleich ist als ein anderer, notieren Sie die Zeichen `>=`.
Um abzufragen, ob ein Wert in jedem Fall größer ist als ein anderer, notieren Sie das Zeichen `>`.
Um abzufragen, ob ein Wert kleiner oder gleich ist als ein anderer, notieren Sie die Zeichen `<=`.
Um abzufragen, ob ein Wert in jedem Fall kleiner ist als ein anderer, notieren Sie das Zeichen `<`.
Nähere Information zu der If-Abfrage erhalten Sie im Abschnitt über bedingte Anweisungen.

Ab der JavaScript-Version 1.2 können Sie Gleichheit/Ungleichheit nicht nur mit `==` bzw. `!=`, sondern auch mit `===` bzw. `!==` abprüfen. In diesem Fall werden die Werte zusätzlich auf ihren Variablentyp hin überprüft. So wird z.B. die Anweisung `if (SinnDesLebens === "42") alert(1)` nicht ausgeführt. Berücksichtigen Sie bei der Verwendung dieser Operatoren, dass ältere Browser darauf mit einer Fehlermeldung reagieren.

## Berechnungsoperatoren

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

### Beispiel:

    <script type="text/javascript">
    var Zwei = 1 + 1;
    var GarNix = 1 - 1;
    var AuchNix = 81 / 3 - 27;
    var WenigerAlsNix = 81 / (3 - 27);
    var SinnDesLebens = 6 * 7;
    var MachtAuchSinn = 84 / 2;
    var x = Jahr % 4;
    if (x == 0)
      Schaltjahr = true;

    /* Besondere Notationen: */

    var Zahl;
    Zahl += 3;
    Zahl++;
    Zahl -= 2;
    Zahl--;
    Zahl *= 4;
    Zahl /= 3;
    </script>

### 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 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 vierten der obigen Beispiele.

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

## Logische Operatoren

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

### Beispiel:

    <script type="text/javascript">
    var PLZ = 81000;
    var x = 20, y = 8;
    var name = "";

    if (PLZ >= 80000 && PLZ <= 82000)
      alert("Sie wohnen wohl in Muenchen oder Umgebung!");

    if (x > 100 || y == 0)
      break;
    if (!name)
      alert("Sie haben vergessen, einen Namen einzugeben!");
    </script>

### 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.
Der logische Operator `!` (engl. not) prüft, ob ein Ausdruck unwahr ist. Der Ausdruck `if (!name)` trifft zu, wenn `name` gleich `null`, 0, ein Leerstring oder undefiniert 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
`~` Bitweise Nicht-Operator, tauscht alle Nullen in Einsen und umgekehrt

## Operator zur Zeichenkettenverknüpfung

Mit einem einfachen Pluszeichen `+` können Sie eine Zeichenkette an eine andere anhängen.

### Beispiel:

    <script type="text/javascript">
    var Vorname = "Stefan ";
    var Zuname = "Muenz";
    var Name = Vorname + Zuname + ", der Autor dieses Dokuments";
    </script>

### Erläuterung:

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

## Operatorenrangfolge

Unter den Operatoren von JavaScript 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: `= += -= <<= >>= &= ^= |=`
3. Rangstufe: `?:` ( Entweder-Oder-Bedingung)
4. Rangstufe: `||`
5. Rangstufe: `&&`
6. Rangstufe: `|`
7. Rangstufe: `^`
8. Rangstufe: `&`
9. Rangstufe: `== === != !==`
10. Rangstufe: `< <= > >=`
11. Rangstufe: `<< >> >>>`
12. Rangstufe: `+ -`
13. Rangstufe: `* / %`
14. Rangstufe: `! ~ - ++ --`
15. Rangstufe: `() [] .` (Klammerung und Vektoren)

Mit Hilfe von Klammern, die absichtlich die unterste Rangstufe in der Prioritätshierarchie darstellen, können Sie die Rangfolge bei den Operatoren beeinflussen und Ausdrücke so bewerten, wie Sie es wünschen.

### Beispiel:

    <script type="text/javascript">
    var OffizielleStatistik = 3.29 * 3 + 4.71;
    var MeineStatistik = 3.29 * (3 + 4.71);
    </script>

### Erläuterung:

Das Beispiel zeigt, wie Sie durch Setzen von Klammern das Ergebnis einer Rechenoperation beeinflussen können.

## Operator zur Typenbestimmung

Methoden vordefinierter Objekte sind an feste Variablentypen gebunden. Bevor Sie diese verwenden können, sollten Sie im Zweifelsfall den Typ der Variable prüfen. Mit dem Operator `typeof` steht Ihnen ein Werkzeug zur Typenüberprüfung zur Verfügung.

### Beispiel:

    <script type="text/javascript">
    var Zahl = 2505;
    alert(typeof Zahl);
    </script>

### Erläuterung:

Der Operator `typeof` wertet den nachfolgenden Operanden hinsichtlich seines Typs aus. Der Rückgabewert dieses Operators ist ein String, den Sie abfragen können. Mögliche Rückgabewerte sind:
`boolean` (Ja/Nein-Variable),
`string` (Zeichenkettenvariable),
`number` (numerische Variable),
`function` (Funktion),
`object` (Objekt),
`undefined` (unbestimmter Typ).
Anweisungen müssen in Klammern eingeschlossen werden, z.B. `typeof(Zahl=Zahl+2)`.

## void-Operator

Der Operator `void` wird dann verwendet, wenn eine Anweisung ausgeführt werden soll, aber keine Rückgabewerte erzeugt werden dürfen. Das ist z.B. dann der Fall, wenn Sie so genannte "Bookmarklets" erzeugen möchten.

### Beispiel:

    <script type="text/javascript">
    var Zahl = 2505;
    void Zahl++;
    </script>

### Erläuterung:

Der Operator `void` führt die nach ihm notierte Anweisung aus. Der Operator ersetzt dabei die Rückgabewerte der Anweisung stets durch `undefined`. Sie können auch eine Anweisung wie z.B. `Zahl=Zahl+2` als Operand angeben. In diesem Fall schließen Sie die Anweisung in Klammern ein, also `void(Zahl=Zahl+2)`.

## Operator zum Löschen von Objekten

Nicht mehr benötigte Objekte bzw. Objekteigenschaften werden mit dem Operator `delete` gelöscht. Sie können jedoch keine vordefinierten Objekte und Objekteigenschaften löschen. Der Operator gibt im Erfolgsfall den Wert `true` und bei Misserfolg den Wert `false` zurück.

### Beispiel:

    <script type="text/javascript">
    SinnDesLebens = 42;
    delete SinnDesLebens;
    alert(typeof SinnDesLebens);
    </script>

### Erläuterung:

Im Beispiel wird der Variablen `SinnDesLebens` der Wert `42` zugewiesen. Anschließend wird diese Variable mit `delete` wieder gelöscht. Mit Hilfe des Operators `typeof` wird überprüft, ob das Löschen der Variablen erfolgreich ist.

### Beachten Sie:

In Netscape bis einschließlich Version 6 können nur Variablen und Objekte gelöscht werden, die nicht mit dem Schlüsselwort `var` deklariert wurden.

Auf vordefinierte Objekte oder Objekteigenschaften wie z.B. `Math.PI` können Sie diesen Operator nicht anwenden.

| Bedingte Anweisungen (if-else/switch)
| Steuerzeichen und besondere Notationen

© 2007 Impressum