Ausdrücke und Operatoren

  • Adressname der Version: JavaScript/javascript_guide/Ausdrücke_und_Operatoren
  • Titel der Version: Ausdrücke und Operatoren
  • ID der Version: 265378
  • Erstellt:
  • Autor: eminor
  • Aktuelle Version? Nein
  • Kommentar 101 words added, 105 words removed

Inhalt der Version

Dieses Kapitel beschreibt Ausdrücke und Operatoren in Javascript. Dazu gehören Zuweisungen, Vergleiche, Arithmetik sowie bitweise, logische, String- und spezielle Operatoren.

Ausdrücke

Ein Ausdruck ist jede gültige Einheit von Code, der ausgewertet werden kann und einen Wert liefert.

Konzeptuell gibt es zwei verschiedene Arten von Ausdrücken: Entweder wird einer Variablen ein Wert zugewiesen oder der Ausdruck selbst hat einen Wert und wird direkt ausgewertet. Zum Beispiel ist die Zuweisung x = 7 ein Ausdruck, der x den Wert 7 zuweist und gleichzeitig liefert dieser Ausdruck selbst den Wert 7 zurück. Diese Art von Ausdrücken benutzen Zuweisungsoperatoren. Beim Ausprobieren in der interaktiven Konsole lässt sich nachvollziehen, dass bei der Zuweisung der Wert 7 zurückgegeben wird. Andererseits liefert der Ausdruck 3 + 4 ebenfalls 7 als Ergebnis, ohne dass hier eine Zuweisung stattfindet. Die Operatoren, die in solchen Ausdrücken benutzt werden, haben keine spezielle Bezeichnung, sondern werden einfach Operatoren genannt.

JavaScript kennt die folgenden Arten von Ausdrücken:

  • Arithmetisch: liefern eine Zahl, z.B. 3.14159. (Grundsätzlich werden {{ web.link("#Arithmetic_operators", "arithmetische Operatoren") }} benutzt.)
  • String: liefern eine Zeichenkette, z.B. "Fred" oder "234". (Grundsätzlich werden {{ web.link("#String_operators", "String-Operatoren") }} benutzt.)
  • Logisch: liefern true oder false. (Oft werden {{ web.link("#Logical_operators", "Logische Operatoren") }} verwendet.)
  • Objekt: liefern ein Objekt. (Siehe {{ web.link("#Special_operators", "Spezielle Operatoren") }} für diverse Ausdrücke, die Objekte liefern.)

Operatoren

Dieser Abschnitt beschriebt die Operatoren und die Operatorenrangfolge, d.h. welcher Teil eines Ausdrucks zuerst ausgewertet wird und die Reihenfolge der darauf folgenden Auswertungen.

  • {{ web.link("#Assignment_operators", "Assignment operators") }}
  • {{ web.link("#Comparison_operators", "Comparison operators") }}
  • {{ web.link("#Arithmetic_operators", "Arithmetic operators") }}
  • {{ web.link("#Bitwise_operators", "Bitwise operators") }}
  • {{ web.link("#Logical_operators", "Logical operators") }}
  • {{ web.link("#String_operators", "String operators") }}
  • {{ web.link("#Special_operators", "Special operators") }}

JavaScript arbeitet sowohl mit binären als auch mit unären Operatoren. Zudem kommt ein spezieller ternärer Operator, der Vergleichsoperator, zum Einsatz. Ein binärer Operator benötigt zwei Operanden - der eine steht vor und der andere hinter dem Operator.

Operand1 Operator Operand2

Zum Beispiel 3 + 4 oder x * y.

Ein unärer Operator benötigt nur einen einzelnen Operanden, der entweder vor oder hinter dem Operator steht.

Operator Operand

oder

Operand Operator

Zum Beispiel x++ oder ++x.

Zuweisungsoperatoren

Ein Zuweisungsoperator weist dem Operanden, der auf der linken Seite des Operators steht, den Wert des Operanden zu, der auf der rechten Seite des Operators steht. Der grundlegende Zuweisungsoperator ist das Gleichzeichen (=), womit dem linken Operanden der Wert des rechten Operanden zugewiesen wird. Das bedeutet x = y weist x den Wert von y zu.

Die anderen Zuweisungsoperatoren sind eine Kurzschreibweise für Standardoperationen. Die nachstehende Tabelle zeigt deren Bedeutung:

Tabelle 3.1 Zuweisungsoperatoren
Kurzschreibweise Bedeutung
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x /= y x = x / y
x %= y x = x % y
x <<= y x = x << y
x >>= y x = x >> y
x >>>= y x = x >>> y
x &= y x = x & y
x ^= y x = x ^ y
x |= y x = x | y

Vergleichsoperatoren

Ein Vergleichsoperator vergleicht den Wert seiner Operanden und liefert dann einen logischen Wert zurück. Die zum Vergleich herangezogenen Operanden können numerische oder logische Werte, aber auch Zeichenketten oder Objekte sein. Zeichenketten werden anhand ihrer lexographischen Ordnung (bezogen auf Unicode) verglichen. Sind die Operatoren nicht vom selben Typ, versucht Javascript in den meisten Fällen, die Operanden zu einem Typ umzuwandeln, der für den Vergleich für sinnvoll erachtet wird. Eine Ausnahme sind die Operatoren === und !==, welche "strikte" Vergleiche durchführen - Sie vergleichen nicht nur, ob der Wert der Operanden übereinstimmt sondern auch, ob es sich um denselben Datentyp handelt. Des Weiteren versuchen sie nicht, die Operanden vor dem Vergleich umzuwandeln. Dies führt in der Regel dazu, dass ein numerischer Vergleich durchgeführt wird. Die folgende Tabelle beschreibt die Vergleichsoperatoren bezogen auf den folgenden Code:

var var1 = 3, var2 = 4;
Tabelle 3.2 Vergleichsoperatoren
Operator Beschreibung Beispiele, die true liefern
Gleich (==) Liefert true, wenn die Operanden gleich sind. 3 == var1

"3" == var1

3 == '3'
Ungleich (!=) Liefert true, wenn die Operanden nicht gleich sind. var1 != 4
var2 != "3"
Strikt Gleich (===) Liefert true, wenn die Operanden gleich und vom gleichen Datentyp sind. 3 === var1
Strikt-Ungleich (!==) Liefert true, wenn die Operanden nicht gleich und/oder nicht vom selben Datentyp sind. var1 !== "3"
3 !== '3'
Größer als (>) Liefert true, wenn der Linke Operand größer als der rechte Operand ist. var2 > var1
"12" > 2
Größer oder Gleich (>=) Liefert true, wenn der linke Operand größer oder gleich ist als der rechte Operand. var2 >= var1
var1 >= 3
Kleiner als (<) Liefert true, wenn der linke Operand kleiner als der rechte Operand ist. var1 < var2
"12" < "2"
Kleiner oder gleich (<=) Liefert true, wenn der linke Operand kleiner oder gleich dem rechten Operanden ist. var1 <= var2
var2 <= 5

Arithmetische Operatoren

Arithmetische Operatoren (Rechenoperatoren) arbeiten mit numerischen Werten (entweder Literale oder Variablen) als Operanden und geben einzelne numerische Werte zurück. Die Standard-Operatoren für arithmetische Operationen sind die Operatoren für Addition (+), Subtraktion (-), Multiplikation (*) und Division (/). Diese Operatoren funktionieren wie bei den meisten anderen Programmiersprachen, wenn sie auf Gleitkommazahlen angewendet werden (Achtung: Eine Division durch Null ergibt NaN).

Zum Beispiel:

console.log(1 / 2); /* ergibt 0.5 */
console.log(1 / 2 == 1.0 / 2.0); /* liefert true */

Ferner stellt JavaScript die arithmetischen Operatoren zur Verfügung, die in der Tabelle aufgelistet sind:

Tabelle 3.3 Arithmetische Operatoren
Operator Beschreibung Beispiel
%
(Modulo)
Binärer Operator. Liefert den ganzzahligen Restwert der Division der beiden Operanden. 12 % 5 ergibt 2.
++
(Inkrement)
Unärer Operator. Addiert eins zum Operanden. Wenn er als Präfix-Operator verwendet wird, d.h. dem Operanden vorangestellt (++x), wird der Wert des Operanden ausgewertet bevor der Wert um 1 erhöht wurde; wenn er als Postfix-Operator benutzt wird, d.h. dem Operator hintangestellt (x++), wird der Operand ausgewertet, bevor eins hinzuaddiert wurde. Wenn der Wert von x 3 ist, setzt ++x den Wert von x auf 4 und gibt 4 zurück, während x++ zuerst den Wert 3 zurückgibt und erst dann x auf 4 erhöht.
--
(Dekrement)
Unärer Operator. Subtrahiert 1 vom Operanden. Verhält sich wie der Inkrement-Operator, statt addiert wird jedoch subtrahiert. Wenn der Wert von x 3 ist, dann setzt --x den Wert von x auf 2 und gibt 2 zurück, während x-- zuerst 3 zurückgibt und erst dann x auf 2 setzt.
-
(Unäre Negation)
Unärer Operator. Liefert die Negation seines Operanden. Wenn x 3 ist, dann gibt -x den Wert -3 zurück.

Bitweise Operatoren

Bitweise Operatoren behandeln ihre Operanden wie einen Satz von 32 Bits (Nullen und Einsen), anstatt wie dezimale, hexadezimale oder oktale Zahlen. Zum Beispiel wird die Dezimalzahl 9 durch den binären Wert 1001 repräsentiert. Bitweise Operatoren arbeiten mit solchen Binärwerten, geben jedoch normale numerische Werte zurück.

Die nachstehende Tabelle beschreibt bitweise Operatoren und ihre Eigenschaften.

Tabelle 3.4 Bitweise Operatoren
Operator Verwendung Beschreibung
Bitweises UND a & b Überprüft bei jeder Bitposition, ob der entsprechende Wert bei beiden Operanden (a UND b) eins ist und gibt dann eins zurück.
Bitweises ODER a | b Überprüft bei jeder Bitposition, ob der entsprechende Wert bei einem der beiden Operanden (a ODER b) oder beiden Operanden eins ist und gibt dann eins zurück.
Bitweises XOR a ^ b Überprüft bei jeder Bitposition, ob der entsprechende Wert bei einem der beiden Operanden aber nicht bei beiden Operanden eins ist und gibt dann eins zurück.
Bitweises NICHT ~ a Invertiert die Bits des Operanden.
Bitweise Linksverschiebeung a << b Verschiebt die binäre Repräsentation von a um b Stellen nach links, während von rechts Nullen nachgeschoben werden.
Rechtsverschiebung mit Beachtung des Vorzeichens a >> b Verschiebt die binäre Repräsentation von a um b Stellen nach rechts, während bei einem positiven Vorzeichen von links Nullen nachgeschoben werden und bei einem negativen Vorzeichen Einsen.
Rechtsverschiebung ohne Beachtung des Vorzeichens a >>> b Verschiebt die binäre Repräsentation von a um b Stellen nach rechts, ohne Beachtung des Vorzeichens.

Bitweise logische Operatoren

Generell arbeiten die bitweisen Operatoren folgendermaßen:

  • Die Operanden werden zu 32-Bit-Integern konvertiert und durch eine Reihe von Bits (Nullen und Einsen) dargestellt.
  • Jedes Bit des ersten Operanden wird dem Bit des zweiten Operanden, das an derselben Position steht, paarweise gegenüber gestellt: das erstes Bit des ersten Operanden dem ersten Bit des zweiten Operanden, das zweites Bit des ersten Operanden dem zweitem Bit des zweiten Operanden, usw.
  • Der Operator wird auf jedes der Paare angewendet und das Ergebnis bitweise konstruiert.

Zum Beispiel ist die bitweise Repräsentation von 9 die binäre Zahl 1001 und die binäre Repräsentation von 15 ist 1111. Wenn die bitweisen Operatoren auf diese Zahlen angewendet werden, ist das Ergebnis wie folgt:

Tabelle 3.5 Beispiele zu Bitweisen Operatoren
Ausdruck Ergebnis Binäre Darstellung
15 & 9 9 1111 & 1001 = 1001
15 | 9
15
1111 | 1001 = 1111
15 ^ 9
6
1111 ^ 1001 = 0110
~15
0
~1111 = 0000
~9
6
~1001 = 0110

Bitweise Verschiebungsoperatoren

Die Operatoren für die bitweise Verschiebung nehmen zwei Operanden entgegen: Der erste ist ein Wert, dessen Bits verschoben werden sollen und der zweite Operand legt die Anzahl der Bit-Positionen fest, um die das Bitmuster des ersten Operanden verschoben werden soll. Die Richtung der Verschiebung wird dadurch bestimmt, welcher Operator zum Einsatz kommt.

Verschiebungsoperatoren konvertieren ihre Operanden zu 32-Bit-Zahlen und geben das Ergebnis in Form des Datentyps des linken Operanden zurück.

Die Verschiebungsoperatoren und deren Bedeutung werden in der folgenden Tabelle aufgelistet:

Tabelle 3.6 Bitweise Verschiebungsoperatoren
Operator Beschreibung Beispiel
<<
(Linksverschiebung)
Dieser Operator verschiebt den ersten Operanden um die Anzahl von Bitstellen nach links, die durch den zweiten Operanden spezifiziert wurden. Die nach links herausgeschobenen Bits werden verworfen und von rechts werden Nullen nachgeschoben. 9<<2 ergibt 36, weil 1001 um zwei Bit-Stellen nach links verschoben 100100 ergibt (1*32 + 0*16 + 0*8 + 1*4 + 0*2 + 0*1 = 36).
>>
(Rechtsverschiebung mit Vorzeichenbeachtung)
Dieser Operator verschiebt den ersten Operanden um die durch den zweiten Operanden spezifizierten Bit-Stellen nach rechts. Überschüssige Bits auf der rechten Seite werden verworfen. Kopien des Bits, das ganz links steht, werden von links eingeschoben. 9>>2 ergibt 2, weil 1001 um 2 Bit-Stellen nach rechts verschoben zu 10 wird, also dezimal 2 (1*2 + 0*1 = 2). Ebenso ergibt -9>>2 -3, weil das Vorzeichen erhalten bleibt.
>>>
(Rechtsverschiebung ohne Vorzeichenbeachtung)
Dieser Operator verschiebt den ersten Operanden um die durch den zweiten Operanden spezifizierten Stellen nach rechts. Überschüssige Bits auf der rechten Seite werden verworfen und von links werden Nullen nachgeschoben. 19>>>2 ergibt 4, weil 10011 um 2 Bit-Stellen verschoeben nach rechts 100 wird, also dezimal 4 (1*4 + 0*2 + 0*1). Bei nicht-negative Zahlen liefern beide Rechtsverschiebungsoperatoren dasselbe Ergebnis.

Logische Operatoren

Logische Operatoren werden typischerweise mit booleschen (logischen) Werten verwendet und geben dann ebenfalls einen booleschen Werte zurück. Die Operatoren && und || geben hingegen den Wert einer ihrer Operanden zurück - werden sie mit nicht-booleschen Werten verwendet kann es sein, dass sie auch einen nicht-booleschen Wert zurückgeben. Die logischen Operatoren sind in der folgenden Tabelle beschrieben.

Tabelle 3.6 Logische Operatoren
Operator Benutzung Beschreibung
&& Ausdruck1 && Ausdruck2 (Logisches UND) Gibt Ausdruck1 zurück, wenn dieser zu false konvertiert werden kann. Andernfalls wird Ausdruck2 zurückgegeben. Demzufolge liefert der Operator && true, wenn boolesche Werte übergeben werden und beide Operanden true sind, ansonsten false.
|| Ausdruck1 || Ausdruck2 (Logisches ODER) Liefert Ausdruck1, wenn dieser zu true konvertiert werden kann, ansonsten wird expr2 zurückgegeben. Demzufolge ist das Ergebnis bei || true, wenn boolesche Werte übergeben werden und einer dieser Werte true ist oder beide true sind. Wenn beide Operanden false sind, ist das Ergebnis false.
! !Ausdruck (Logisches NICHT) Liefert false, wenn der (einzelne) Operand zu true umgewandelt werden kann, ansonsten wird true geliefert.

Beispiele von Ausdrücken, die zu false konvertiert werden können, sind null, 0, leere Strings ("") oder undefined.

Der nachstehende Code zeigt Beispiele zum &&-Operator (logisches UND).

var a1 =  true && true;     // t && t ergibt true
var a2 =  true && false;    // t && f ergibt false
var a3 = false && true;     // f && t ergibt false
var a4 = false && (3 == 4); // f && f ergibt false
var a5 = "Katze" && "Hund";    // t && t ergibt Hund
var a6 = false && "Cat";    // f && t ergibt false
var a7 = "Katze" && false;    // t && f ergibt false

Der folgende Code zeigt Beispiele zum ||-Operator (logisches ODER).

var o1 =  true || true;     // t || t ergibt true
var o2 = false || true;     // f || t ergibt true
var o3 =  true || false;    // t || f ergibt true
var o4 = false || (3 == 4); // f || f ergibt false
var o5 = "Katze" || "Hund";    // t || t ergibt Katze
var o6 = false || "Katze";    // f || t ergibt Katze
var o7 = "Katze" || false;    // t || f ergibt Katze

Der folgende Code zeigt Beispiele zum  !-Operator (logisches NICHT).

var n1 = !true;  // !t ergibt false
var n2 = !false; // !f ergibt true
var n3 = !"Katze"; // !t ergibt false

Kurzschlussauswertung (Short-circuit evaluation)

Logische Ausdrücke werden von links nach rechts ausgewertet und dabei auf mögliche Kurzschlussauswertungen überprüft:

  • false && irgendetwas ist eine Kurzschlussauswertung zu false.
  • true || irgendetwas ist eine Kurzschlussauswertung zu true.

Wenn das Ergebnis bereits nach der Auswertung des ersten Operanden feststeht, wird der andere Teil des Ausdrucks erst gar nicht ausgewertet. Die Regeln der Logik garantieren, dass das Resultat auch dann immer korrekt ist. Da irgendetwas nie ausgewertet wird, kommen auch etwaige Seiteneffekte nie zur Anwendung.

Zeichenkettenoperatoren (String-Operatoren)

Zusätzlich zu den Vergleichsoperatoren, die auch auf String-Werte angewendet werden können, gibt es den Verbindungsoperator (+), der zwei Zeichenketten entgegen nimmt, deren Werte verbindet und als Ergebnis eine neue Zeichenkette liefert, die aus dem Verbund der beiden Zeichenketten besteht. Zum Beispiel ergibt "meine " + "Zeichenkette" den String"meine Zeichenkette".

Der Operator für die Additionszuweisung  (+=) kann auch verwendet werden, um Zeichenketten zu verbinden. Wenn z.B. die Variable meinString den Wert "Alpha" enthält, ist das Ergebnis von meinString += "bet" die Zeichenkette "Alphabet" und diese Zeichenkette wird sogleich der Variablen meinString zugewiesen.

Spezielle Operatoren

JavaScript stellt die folgenden speziellen Operatoren zur Verfügung:

  • {{ web.link("#Conditional_operator", "Conditional operator") }}
  • {{ web.link("#Comma_operator", "Comma operator") }}
  • {{ web.link("#delete", "delete") }}
  • {{ web.link("#in", "in") }}
  • {{ web.link("#instanceof", "instanceof") }}
  • {{ web.link("#new", "new") }}
  • {{ web.link("#this", "this") }}
  • {{ web.link("#typeof", "typeof") }}
  • {{ web.link("#void", "void") }}

Konditionaler Operator

Der konditionale Operator ist der einzige JavaScript-Operator, der drei Operanden entgegennimmt. Der Operator liefert nach der Auswertung einer Bedingung einen von zwei Werten als Ergebnis.

Syntax:

Bedingung ? Wert1 : Wert2

Wenn die Auswertung der Bedingung den Wert true ergibt, hat der Operator den Wert von Wert1, andernfalls den Wert von Wert2. Der Operator kann überall anstatt eines Standardoperators benutzt werden. Auch anstatt von if-else Anweisungen kann der Operator eingesetzt werden.

Beispiel:

var status = (alter >= 18) ? "erwachsen" : "minderjährig";

Diese Anweisung weist der Variablen status den Wert "erwachsen" oder "minderjährig" zu, je nachdem ob der Wert der Variablen alter größer oder gleich 18 ist.

Komma-Operator

Der Kommaoperator (,) wertet einfach beide seiner Operanden (links und rechts) aus und liefert den Wert des zweiten Operanden zurück. Dieser Operator wird vorwiegend innerhalb von for-Schleifen benutzt, um mit mehreren Variablen innerhalb der Schleife zu arbeiten.

Wenn z.B. a ein zweidimensionales Array mit 10 Elementen auf jeder Seite ist, wird beim folgenden Code der Komma-Operator benutzt, um zwei Variablen jeweils bei einem Schleifendurchlauf zu verändern. Der Code gibt die Werte der Array-Elemente aus, die in der Diagonale stehen:

for (var i = 0, j = 9; i <= 9; i++, j--)
  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);

delete

Der delete-Operator löscht ein Objekt, eine Obejekteigenschaft oder ein Element eines spezifizierten Index in einem Array.

Syntax:

delete objektName;
delete objektName.Eigenschaft;
delete objektName[Index];
delete Eigenschaft; // nur zulässig innerhalb einer with-Anweisung

objektName ist der Name eines Objekts, Eigenschaft ist eine existierende Eigenschaft und Index eine Zahl, welche die Position eines Elements innerhalb eines Arrays angibt.

Die vierte Anweisung ist nur innerhalb einer with-Anweisung erlaubt, um eine Eigenschaft eines Objekts zu entfernen.

Mit dem delete-Operator kann man Variablen löschen, die implizit deklariert wurden, nicht jedoch solche, die mit var deklariert wurden.

Wenn der delete-Operator beim Löschen erfolgreich ist, setzt er die Eigenschaft oder das Element auf undefined. Der delete-Operator gibt true zurück, wenn die Ausführung möglich ist, ansonsten wird false zurückgegeben.

x = 42;
var y = 43;
meinobj = new Number();
meinobj.h = 4;    // erzeuge Eigenschaft h
delete x;       // ergibt true (löschen funktioniert, da implizit deklariert)
delete y;       // ergibt false (löschen funktioniert nicht, weil mit var deklariert)
delete Math.PI; // ergibt false (löschen funktioniert nicht, weil vordefinierte Eigenschaft)
delete meinobj.h; // ergibt true (löschen funktioniert bei benutzerdefinierten Eigenschaften)
delete meinobj;   // ergibt true (löschen funktioniert, da implizit deklariert)
Löschen von Array-Elementen

Wenn man ein Array-Element löscht, wird die Länge des Arrays dadruch nicht beeinflusst. Zum Beispiel ist nach dem Löschen von a[3] das Element a[4] immer noch a[4], jedoch ist a[3] nun undefined.

Wenn der delete-Operator ein Element entfernt, ist dieses Element nicht mehr im Array. Beim folgenden Beispiel wird trees[3] mit delete entfernt. Anschließend ist das Element trees[3] zwar noch immer addressierbar, liefert jedoch undefined.

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
if (3 in trees) {
  // wird nicht ausgeführt
}

Wenn man möchte, dass ein Array-Element zwar exisitert, aber undefined ist, sollte man das undefined-Schlüsselwort statt des delete-Operators benutzen. Beim folgenden Beispiel wird trees[3] der Wert undefined zugewiesen und das Array-Element bleibt bestehen:

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
if (3 in trees) {
  // wird ausgeführt
}

in

Der in-Operator gibt true zurück, wenn die entsprechende Eigenschaft im angegebenen Objekt existiert.

Syntax:

EigenschNameOderNummer in objektName

wobei EigenschNameOderNummer ein String oder ein numerischer Ausdruck sein kann, der für einen Eigenschaftsnamen oder Array-Index steht und objektName der Name eines Objekts ist.

Das Beispiel demonstriert die Benutzung des in-Operators:

// Arrays
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
0 in trees;        // ergibt true
3 in trees;        // ergibt true
6 in trees;        // ergibt false
"bay" in trees;    // ergibt false (es muss die Index-Nummer angegeben werden,
                   // nicht der Wert)
"length" in trees; // ergibt true (length ist eine Array-Eigenschaft)

// Vordefinierte Objekte
"PI" in Math;          // ergibt true
var myString = new String("coral");
"length" in myString;  // ergibt true

// Selbstdefinierte Objekte
var mycar = {make: "Honda", model: "Accord", year: 1998};
"make" in mycar;  // ergibt true
"model" in mycar; // ergibt true

instanceof

Der instanceof-Operator gibt true zurück, wenn das spezifizierte Objekt vom angegebenen Typ ist.

Syntax:

objektName instanceof objektTyp

wobei objektName der Name des Objekts ist, dessen Typ mit objektTyp verglichen werden soll;  objektTyp is ein Objekttyp, wie z.B. Date oder Array.

Mit instanceof überprüft man während der Laufzeit, ob ein Objekt von einem bestimmten Typ ist. Zum Beispiel kann man bei der Fehlerbehandlung je nach Typ unterschiedlichen Code ausführen lassen.

Der folgende Code greift auf instanceof zurück, um festzustellen, ob es sich bei derTag um ein Date-Objekt handelt und weil dies zutrifft, wird der Code der if-Anweisung ausgeführt.

var theDay = new Date(1995, 12, 17);
if (theDay instanceof Date) {
  // statements to execute
}

new

Mit dem new-Operator erzeugt man Instanzen eines benutzerdefinierten Objekts oder Instanzen von vordefinierten Objekten wie Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp, oder String. Serverseitig kann er auch mit DbPool, Lock, File, oder SendMail benutzt werden.

Syntax:

var objektName = new objektTyp([param1, param2, ..., paramN]);

Objekte kann man auch mit mit Objekt-Intializern erzeugen, wie unter {{ web.link("Working_with_objects#Using_object_initializers", "using object initializers") }} beschreiben.

Auf der Seite new operator der Core JavaScript Referenz findet man mehr Informationen.

this

Mit dem Schlüsselwort this verweist man auf das eigene Objekt.

##############

Use the this keyword to refer to the current object. In general, this refers to the calling object in a method. Use this as follows:

this["propertyName"]
this.propertyName

Example 1.
Suppose a function called validate validates an object's value property, given the object and the high and low values:

function validate(obj, lowval, hival){
  if ((obj.value < lowval) || (obj.value > hival))
    alert("Invalid Value!");
}

You could call validate in each form element's onChange event handler, using this to pass it the form element, as in the following example:

<B>Enter a number between 18 and 99:</B>
<INPUT TYPE="text" NAME="age" SIZE=3
   onChange="validate(this, 18, 99);">

Example 2.
When combined with the form property, this can refer to the current object's parent form. In the following example, the form myForm contains a Text object and a button. When the user clicks the button, the value of the Text object is set to the form's name. The button's onClick event handler uses this.form to refer to the parent form, myForm.

<FORM NAME="myForm">
Form name:<INPUT TYPE="text" NAME="text1" VALUE="Beluga">
<P>
<INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
   onClick="this.form.text1.value = this.form.name;">
</FORM>

typeof

The typeof operator is used in either of the following ways:

  1. typeof operand
    
  2. typeof (operand)
    

The typeof operator returns a string indicating the type of the unevaluated operand. operand is the string, variable, keyword, or object for which the type is to be returned. The parentheses are optional.

Suppose you define the following variables:

var myFun = new Function("5 + 2");
var shape = "round";
var size = 1;
var today = new Date();

The typeof operator returns the following results for these variables:

typeof myFun;     // returns "function"
typeof shape;     // returns "string"
typeof size;      // returns "number"
typeof today;     // returns "object"
typeof dontExist; // returns "undefined"

For the keywords true and null, the typeof operator returns the following results:

typeof true; // returns "boolean"
typeof null; // returns "object"

For a number or string, the typeof operator returns the following results:

typeof 62;            // returns "number"
typeof 'Hello world'; // returns "string"

For property values, the typeof operator returns the type of value the property contains:

typeof document.lastModified; // returns "string"
typeof window.length;         // returns "number"
typeof Math.LN2;              // returns "number"

For methods and functions, the typeof operator returns results as follows:

typeof blur;        // returns "function"
typeof eval;        // returns "function"
typeof parseInt;    // returns "function"
typeof shape.split; // returns "function"

For predefined objects, the typeof operator returns results as follows:

typeof Date;     // returns "function"
typeof Function; // returns "function"
typeof Math;     // returns "object"
typeof Option;   // returns "function"
typeof String;   // returns "function"

void

The void operator is used in either of the following ways:

  1. void (expression)
    
  2. void expression
    

The void operator specifies an expression to be evaluated without returning a value. expression is a JavaScript expression to evaluate. The parentheses surrounding the expression are optional, but it is good style to use them.

You can use the void operator to specify an expression as a hypertext link. The expression is evaluated but is not loaded in place of the current document.

The following code creates a hypertext link that does nothing when the user clicks it. When the user clicks the link, void(0) evaluates to undefined, which has no effect in JavaScript.

<A HREF="javascript:void(0)">Click here to do nothing</A>

The following code creates a hypertext link that submits a form when the user clicks it.

<A HREF="javascript:void(document.form.submit())">
Click here to submit</A>

Operator precedence

The precedence of operators determines the order they are applied when evaluating an expression. You can override operator precedence by using parentheses.

The following table describes the precedence of operators, from highest to lowest.

In accordance with relevant discussion, this table was reversed to list operators in decreasing order of priority.

Table 3.7 Operator precedence
Operator type Individual operators
member .  []
call / create instance ()  new
negation/increment !  ~  -  +  ++  --  typeof  void  delete
multiply/divide *  /  %
addition/subtraction +  -
bitwise shift <<  >>  >>>
relational <  <=  >  >=  in  instanceof
equality ==  !=  ===  !==
bitwise-and &
bitwise-xor ^
bitwise-or |
logical-and &&
logical-or ||
conditional ?:
assignment =  +=  -=  *=  /=  %=  <<=  >>=  >>>=  &=  ^=  |=
comma ,

A more detailed version of this table, complete with links to additional details about each operator, may be found in JavaScript Reference.

autoPreviousNext("JSGChapters");

Quelltext der Version

<p>Dieses Kapitel beschreibt Ausdrücke und Operatoren in Javascript. Dazu gehören Zuweisungen, Vergleiche, Arithmetik sowie bitweise, logische, String- und spezielle Operatoren.</p>
<h2>Ausdrücke</h2>
<p>Ein <em>Ausdruck</em> ist jede gültige Einheit von Code, der ausgewertet werden kann und einen Wert liefert.</p>
<p>Konzeptuell gibt es zwei verschiedene Arten von Ausdrücken: Entweder wird einer Variablen ein Wert zugewiesen oder der Ausdruck selbst hat einen Wert und wird direkt ausgewertet. Zum Beispiel ist die Zuweisung <code>x = 7</code> ein Ausdruck, der x den Wert <code>7</code> zuweist und gleichzeitig liefert dieser Ausdruck selbst den Wert 7 zurück. Diese Art von Ausdrücken benutzen <em>Zuweisungsoperatoren</em>. Beim Ausprobieren in der interaktiven Konsole lässt sich nachvollziehen, dass bei der Zuweisung der Wert <code>7</code> zurückgegeben wird. Andererseits liefert der Ausdruck <code>3 + 4</code> ebenfalls <code>7</code> als Ergebnis, ohne dass hier eine Zuweisung stattfindet. Die Operatoren, die in solchen Ausdrücken benutzt werden, haben keine spezielle Bezeichnung, sondern werden einfach <em>Operatoren</em> genannt.</p>
<p>JavaScript kennt die folgenden Arten von Ausdrücken:</p>
<ul> <li>Arithmetisch: liefern eine Zahl, z.B. 3.14159. (Grundsätzlich werden {{ web.link("#Arithmetic_operators", "arithmetische Operatoren") }} benutzt.)</li> <li>String: liefern eine Zeichenkette, z.B. "Fred" oder "234". (Grundsätzlich werden {{ web.link("#String_operators", "String-Operatoren") }} benutzt.)</li> <li>Logisch: liefern true oder false. (Oft werden {{ web.link("#Logical_operators", "Logische Operatoren") }} verwendet.)</li> <li>Objekt: liefern ein Objekt. (Siehe {{ web.link("#Special_operators", "Spezielle Operatoren") }} für diverse Ausdrücke, die Objekte liefern.)</li>
</ul>
<h2>Operatoren</h2>
<p>Dieser Abschnitt beschriebt die Operatoren und die Operatorenrangfolge, d.h. welcher Teil eines Ausdrucks zuerst ausgewertet wird und die Reihenfolge der darauf folgenden Auswertungen.</p>
<ul> <li>{{ web.link("#Assignment_operators", "Assignment operators") }}</li> <li>{{ web.link("#Comparison_operators", "Comparison operators") }}</li> <li>{{ web.link("#Arithmetic_operators", "Arithmetic operators") }}</li> <li>{{ web.link("#Bitwise_operators", "Bitwise operators") }}</li> <li>{{ web.link("#Logical_operators", "Logical operators") }}</li> <li>{{ web.link("#String_operators", "String operators") }}</li> <li>{{ web.link("#Special_operators", "Special operators") }}</li>
</ul>
<p>JavaScript arbeitet sowohl mit <em>binären</em> als auch mit <em>unären</em> Operatoren. Zudem kommt ein spezieller <em>ternärer</em> Operator, der Vergleichsoperator, zum Einsatz. Ein binärer Operator benötigt zwei Operanden - der eine steht vor und der andere hinter dem Operator.</p>
<pre><em>Operand1</em> <em>Operator</em> <em>Operand2</em>
</pre>
<p>Zum Beispiel <code>3 + 4</code> oder <code>x * y</code>.</p>
<p>Ein unärer Operator benötigt nur einen einzelnen Operanden, der entweder vor oder hinter dem Operator steht.</p>
<pre><em>Operator</em> <em>Operand</em>
</pre>
<p>oder</p>
<pre><em>Operand</em> <em>Operator</em>
</pre>
<p>Zum Beispiel <code>x++</code> oder <code>++x</code>.</p>
<h3>Zuweisungsoperatoren</h3>
<p>Ein Zuweisungsoperator weist dem Operanden, der auf der linken Seite des Operators steht, den Wert des Operanden zu, der auf der rechten Seite des Operators steht. Der grundlegende Zuweisungsoperator ist das Gleichzeichen (=), womit dem linken Operanden der Wert des rechten Operanden zugewiesen wird. Das bedeutet x = y weist x den Wert von y zu.</p>
<p>Die anderen Zuweisungsoperatoren sind eine Kurzschreibweise für Standardoperationen. Die nachstehende Tabelle zeigt deren Bedeutung:</p>
<table class="standard-table"> <caption style="text-align: left;">Tabelle 3.1 Zuweisungsoperatoren</caption> <thead> <tr> <th scope="col" width="50%">Kurzschreibweise</th> <th scope="col" width="50%">Bedeutung</th> </tr> </thead> <tbody> <tr> <td><code>x += y</code></td> <td><code>x = x + y</code></td> </tr> <tr> <td><code>x -= y</code></td> <td><code>x = x - y</code></td> </tr> <tr> <td><code>x *= y</code></td> <td><code>x = x * y</code></td> </tr> <tr> <td><code>x /= y</code></td> <td><code>x = x / y</code></td> </tr> <tr> <td><code>x %= y</code></td> <td><code>x = x % y</code></td> </tr> <tr> <td><code>x &lt;&lt;= y</code></td> <td><code>x = x &lt;&lt; y</code></td> </tr> <tr> <td><code>x &gt;&gt;= y</code></td> <td><code>x = x &gt;&gt; y</code></td> </tr> <tr> <td><code>x &gt;&gt;&gt;= y</code></td> <td><code>x = x &gt;&gt;&gt; y</code></td> </tr> <tr> <td><code>x &amp;= y</code></td> <td><code>x = x &amp; y</code></td> </tr> <tr> <td><code>x ^= y</code></td> <td><code>x = x ^ y</code></td> </tr> <tr> <td><code>x |= y</code></td> <td><code>x = x | y</code></td> </tr> </tbody>
</table>
<h3>Vergleichsoperatoren</h3>
<p>Ein Vergleichsoperator vergleicht den Wert seiner Operanden und liefert dann einen logischen Wert zurück. Die zum Vergleich herangezogenen Operanden können numerische oder logische Werte, aber auch Zeichenketten oder Objekte sein. Zeichenketten werden anhand ihrer lexographischen Ordnung (bezogen auf Unicode) verglichen. Sind die Operatoren nicht vom selben Typ, versucht Javascript in den meisten Fällen, die Operanden zu einem Typ umzuwandeln, der für den Vergleich für sinnvoll erachtet wird. Eine Ausnahme sind die Operatoren <code>===</code> und <code>!==</code>, welche "strikte" Vergleiche durchführen - Sie vergleichen nicht nur, ob der Wert der Operanden übereinstimmt sondern auch, ob es sich um denselben Datentyp handelt. Des Weiteren versuchen sie nicht, die Operanden vor dem Vergleich umzuwandeln. Dies führt in der Regel dazu, dass ein numerischer Vergleich durchgeführt wird. Die folgende Tabelle beschreibt die Vergleichsoperatoren bezogen auf den folgenden Code:</p>
<pre class="brush: js">var var1 = 3, var2 = 4;
</pre>
<table class="standard-table"> <caption style="text-align: left;">Tabelle 3.2 Vergleichsoperatoren</caption> <thead> <tr> <th scope="col">Operator</th> <th scope="col">Beschreibung</th> <th scope="col">Beispiele, die true liefern</th> </tr> </thead> <tbody> <tr> <td>Gleich (<code>==</code>)</td> <td>Liefert true, wenn die Operanden gleich sind.</td> <td><code>3 == var1</code><br> <p><code>"3" == var1</code></p> <code>3 == '3'</code></td> </tr> <tr> <td>Ungleich (<code>!=</code>)</td> <td>Liefert true, wenn die Operanden nicht gleich sind.</td> <td><code>var1 != 4<br> var2 != "3"</code></td> </tr> <tr> <td>Strikt Gleich (<code>===</code>)</td> <td>Liefert true, wenn die Operanden gleich und vom gleichen Datentyp sind.</td> <td><code>3 === var1</code></td> </tr> <tr> <td>Strikt-Ungleich (<code>!==</code>)</td> <td>Liefert true, wenn die Operanden nicht gleich und/oder nicht vom selben Datentyp sind.</td> <td><code>var1 !== "3"<br> 3 !== '3'</code></td> </tr> <tr> <td>Größer als (<code>&gt;</code>)</td> <td>Liefert true, wenn der Linke Operand größer als der rechte Operand ist.</td> <td><code>var2 &gt; var1<br> "12" &gt; 2</code></td> </tr> <tr> <td>Größer oder Gleich (<code>&gt;=</code>)</td> <td>Liefert true, wenn der linke Operand größer oder gleich ist als der rechte Operand.</td> <td><code>var2 &gt;= var1<br> var1 &gt;= 3</code></td> </tr> <tr> <td>Kleiner als (<code>&lt;</code>)</td> <td>Liefert true, wenn der linke Operand kleiner als der rechte Operand ist.</td> <td><code>var1 &lt; var2<br> "12" &lt; "2"</code></td> </tr> <tr> <td>Kleiner oder gleich (<code>&lt;=</code>)</td> <td>Liefert true, wenn der linke Operand kleiner oder gleich dem rechten Operanden ist.</td> <td><code>var1 &lt;= var2<br> var2 &lt;= 5</code></td> </tr> </tbody>
</table>
<h3>Arithmetische Operatoren</h3>
<p>Arithmetische Operatoren (Rechenoperatoren) arbeiten mit numerischen Werten (entweder Literale oder Variablen) als Operanden und geben einzelne numerische Werte zurück. Die Standard-Operatoren für arithmetische Operationen sind die Operatoren für Addition (+), Subtraktion (-), Multiplikation (*) und Division (/). Diese Operatoren funktionieren wie bei den meisten anderen Programmiersprachen, wenn sie auf Gleitkommazahlen angewendet werden (Achtung: Eine Division durch Null ergibt <a href="/en/JavaScript/Reference/Global_Objects/NaN" title="en/Core_JavaScript_1.5_Reference/Global_Properties/NaN"><code>NaN</code></a>).</p>
<p>Zum Beispiel:</p>
<pre class="brush: js">console.log(1 / 2); /* ergibt 0.5 */
console.log(1 / 2 == 1.0 / 2.0); /* liefert true */
</pre>
<p>Ferner stellt JavaScript die arithmetischen Operatoren zur Verfügung, die in der Tabelle aufgelistet sind:</p>
<table class="fullwidth-table"> <caption style="text-align: left;">Tabelle 3.3 Arithmetische Operatoren</caption> <thead> <tr> <th scope="col">Operator</th> <th scope="col">Beschreibung</th> <th scope="col">Beispiel</th> </tr> </thead> <tbody> <tr> <td><code>%</code><br> (Modulo)</td> <td>Binärer Operator. Liefert den ganzzahligen Restwert der Division der beiden Operanden.</td> <td>12 % 5 ergibt 2.</td> </tr> <tr> <td><code>++</code><br> (Inkrement)</td> <td>Unärer Operator. Addiert eins zum Operanden. Wenn er als Präfix-Operator verwendet wird, d.h. dem Operanden vorangestellt (<code>++x</code>), wird der Wert des Operanden ausgewertet bevor der Wert um 1 erhöht wurde; wenn er als Postfix-Operator benutzt wird, d.h. dem Operator hintangestellt (<code>x++</code>), wird der Operand ausgewertet, bevor eins hinzuaddiert wurde.</td> <td>Wenn der Wert von <code>x</code> 3 ist, setzt <code>++x</code> den Wert von <code>x</code> auf 4 und gibt 4 zurück, während <code>x++</code> zuerst den Wert 3 zurückgibt und erst dann <code>x</code> auf 4 erhöht.</td> </tr> <tr> <td><code>--</code><br> (Dekrement)</td> <td>Unärer Operator. Subtrahiert 1 vom Operanden. Verhält sich wie der Inkrement-Operator, statt addiert wird jedoch subtrahiert.</td> <td>Wenn der Wert von <code>x</code> 3 ist, dann setzt <code>--x</code> den Wert von <code>x</code> auf 2 und gibt 2 zurück, während <code>x--</code> zuerst 3 zurückgibt und erst dann <code>x</code> auf 2 setzt.</td> </tr> <tr> <td><code>-</code><br> (Unäre Negation)</td> <td>Unärer Operator. Liefert die Negation seines Operanden.</td> <td>Wenn <code>x</code> 3 ist, dann gibt <code>-x</code> den Wert -3 zurück.</td> </tr> </tbody>
</table>
<h3>Bitweise Operatoren</h3>
<p>Bitweise Operatoren behandeln ihre Operanden wie einen Satz von 32 Bits (Nullen und Einsen), anstatt wie dezimale, hexadezimale oder oktale Zahlen. Zum Beispiel wird die Dezimalzahl 9 durch den binären Wert 1001 repräsentiert. Bitweise Operatoren arbeiten mit solchen Binärwerten, geben jedoch normale numerische Werte zurück.</p>
<p>Die nachstehende Tabelle beschreibt bitweise Operatoren und ihre Eigenschaften.</p>
<table class="standard-table"> <caption style="text-align: left;">Tabelle 3.4 Bitweise Operatoren</caption> <thead> <tr> <th scope="col">Operator</th> <th scope="col">Verwendung</th> <th scope="col">Beschreibung</th> </tr> </thead> <tbody> <tr> <td>Bitweises UND</td> <td><code>a &amp; b</code></td> <td>Überprüft bei jeder Bitposition, ob der entsprechende Wert bei beiden Operanden (a UND b) eins ist und gibt dann eins zurück.</td> </tr> <tr> <td>Bitweises ODER</td> <td><code>a | b</code></td> <td>Überprüft bei jeder Bitposition, ob der entsprechende Wert bei einem der beiden Operanden (a ODER b) oder beiden Operanden eins ist und gibt dann eins zurück.</td> </tr> <tr> <td>Bitweises XOR</td> <td><code>a ^ b</code></td> <td>Überprüft bei jeder Bitposition, ob der entsprechende Wert bei einem der beiden Operanden aber nicht bei beiden Operanden eins ist und gibt dann eins zurück.</td> </tr> <tr> <td>Bitweises NICHT</td> <td><code>~ a</code></td> <td>Invertiert die Bits des Operanden.</td> </tr> <tr> <td>Bitweise Linksverschiebeung</td> <td><code>a &lt;&lt; b</code></td> <td>Verschiebt die binäre Repräsentation von <code>a</code> um <code>b</code> Stellen nach links, während von rechts Nullen nachgeschoben werden.</td> </tr> <tr> <td>Rechtsverschiebung mit Beachtung des Vorzeichens</td> <td><code>a &gt;&gt; b</code></td> <td>Verschiebt die binäre Repräsentation von <code>a</code> um <code>b</code> Stellen nach rechts, während bei einem positiven Vorzeichen von links Nullen nachgeschoben werden und bei einem negativen Vorzeichen Einsen.</td> </tr> <tr> <td>Rechtsverschiebung ohne Beachtung des Vorzeichens</td> <td><code>a &gt;&gt;&gt; b</code></td> <td>Verschiebt die binäre Repräsentation von <code>a</code> um <code>b</code> Stellen nach rechts, ohne Beachtung des Vorzeichens.</td> </tr> </tbody>
</table>
<h4 name="Bitwise_Logical_Operators">Bitweise logische Operatoren</h4>
<p>Generell arbeiten die bitweisen Operatoren folgendermaßen:</p>
<ul> <li>Die Operanden werden zu 32-Bit-Integern konvertiert und durch eine Reihe von Bits (Nullen und Einsen) dargestellt.</li> <li>Jedes Bit des ersten Operanden wird dem Bit des zweiten Operanden, das an derselben Position steht, paarweise gegenüber gestellt: das erstes Bit des ersten Operanden dem ersten Bit des zweiten Operanden, das zweites Bit des ersten Operanden dem zweitem Bit des zweiten Operanden, usw.</li> <li>Der Operator wird auf jedes der Paare angewendet und das Ergebnis bitweise konstruiert.</li>
</ul>
<p>Zum Beispiel ist die bitweise Repräsentation von 9 die binäre Zahl 1001 und die binäre Repräsentation von 15 ist 1111. Wenn die bitweisen Operatoren auf diese Zahlen angewendet werden, ist das Ergebnis wie folgt:</p>
<table class="standard-table"> <caption style="text-align: left;">Tabelle 3.5 Beispiele zu Bitweisen Operatoren</caption> <thead> <tr> <th scope="col">Ausdruck</th> <th scope="col">Ergebnis</th> <th scope="col">Binäre Darstellung</th> </tr> </thead> <tbody> <tr> <td><code>15 &amp; 9</code></td> <td><code>9</code></td> <td><code>1111 &amp; 1001 = 1001</code></td> </tr> <tr> <td><code>15 | 9<br> </code></td> <td><code>15<br> </code></td> <td><code>1111 | 1001 = 1111<br> </code></td> </tr> <tr> <td><code>15 ^ 9<br> </code></td> <td><code>6<br> </code></td> <td><code>1111 ^ 1001 = 0110<br> </code></td> </tr> <tr> <td><code>~15<br> </code></td> <td><code>0<br> </code></td> <td><code>~1111 = 0000<br> </code></td> </tr> <tr> <td><code>~9<br> </code></td> <td><code>6<br> </code></td> <td><code>~1001 = 0110<br> </code></td> </tr> </tbody>
</table>
<h4 name="Bitwise_Shift_Operators">Bitweise Verschiebungsoperatoren</h4>
<p>Die Operatoren für die bitweise Verschiebung nehmen zwei Operanden entgegen: Der erste ist ein Wert, dessen Bits verschoben werden sollen und der zweite Operand legt die Anzahl der Bit-Positionen fest, um die das Bitmuster des ersten Operanden verschoben werden soll. Die Richtung der Verschiebung wird dadurch bestimmt, welcher Operator zum Einsatz kommt.</p>
<p>Verschiebungsoperatoren konvertieren ihre Operanden zu 32-Bit-Zahlen und geben das Ergebnis in Form des Datentyps des linken Operanden zurück.</p>
<p>Die Verschiebungsoperatoren und deren Bedeutung werden in der folgenden Tabelle aufgelistet:</p>
<table class="fullwidth-table"> <caption style="text-align: left;">Tabelle 3.6 Bitweise Verschiebungsoperatoren</caption> <thead> <tr> <th scope="col">Operator</th> <th scope="col">Beschreibung</th> <th scope="col">Beispiel</th> </tr> </thead> <tbody> <tr> <td><code>&lt;&lt;</code><br> (Linksverschiebung)</td> <td>Dieser Operator verschiebt den ersten Operanden um die Anzahl von Bitstellen nach links, die durch den zweiten Operanden spezifiziert wurden. Die nach links herausgeschobenen Bits werden verworfen und von rechts werden Nullen nachgeschoben.</td> <td><code>9&lt;&lt;2</code> ergibt 36, weil 1001 um zwei Bit-Stellen nach links verschoben 100100 ergibt (1*32 + 0*16 + 0*8 + 1*4 + 0*2 + 0*1 = 36).</td> </tr> <tr> <td><code>&gt;&gt;</code><br> (Rechtsverschiebung mit Vorzeichenbeachtung)</td> <td>Dieser Operator verschiebt den ersten Operanden um die durch den zweiten Operanden spezifizierten Bit-Stellen nach rechts. Überschüssige Bits auf der rechten Seite werden verworfen. Kopien des Bits, das ganz links steht, werden von links eingeschoben.</td> <td><code>9&gt;&gt;2</code> ergibt 2, weil 1001 um 2 Bit-Stellen nach rechts verschoben zu 10 wird, also dezimal 2 (1*2 + 0*1 = 2). Ebenso ergibt <code>-9&gt;&gt;2</code> -3, weil das Vorzeichen erhalten bleibt.</td> </tr> <tr> <td><code>&gt;&gt;&gt;</code><br> (Rechtsverschiebung ohne Vorzeichenbeachtung)</td> <td>Dieser Operator verschiebt den ersten Operanden um die durch den zweiten Operanden spezifizierten Stellen nach rechts. Überschüssige Bits auf der rechten Seite werden verworfen und von links werden Nullen nachgeschoben.</td> <td><code>19&gt;&gt;&gt;2</code> ergibt 4, weil 10011 um 2 Bit-Stellen verschoeben nach rechts 100 wird, also dezimal 4 (1*4 + 0*2 + 0*1). Bei nicht-negative Zahlen liefern beide Rechtsverschiebungsoperatoren dasselbe Ergebnis.</td> </tr> </tbody>
</table>
<h3>Logische Operatoren</h3>
<p>Logische Operatoren werden typischerweise mit booleschen (logischen) Werten verwendet und geben dann ebenfalls einen booleschen Werte zurück. Die Operatoren &amp;&amp; und || geben hingegen den Wert einer ihrer Operanden zurück - werden sie mit nicht-booleschen Werten verwendet kann es sein, dass sie auch einen nicht-booleschen Wert zurückgeben. Die logischen Operatoren sind in der folgenden Tabelle beschrieben.</p>
<table class="fullwidth-table"> <caption style="text-align: left;">Tabelle 3.6 Logische Operatoren</caption> <thead> <tr> <th scope="col">Operator</th> <th scope="col">Benutzung</th> <th scope="col">Beschreibung</th> </tr> </thead> <tbody> <tr> <td><code>&amp;&amp;</code></td> <td><code>Ausdruck1 &amp;&amp; Ausdruck2</code></td> <td>(Logisches UND) Gibt <code>Ausdruck1</code> zurück, wenn dieser zu false konvertiert werden kann. Andernfalls wird <code>Ausdruck2</code> zurückgegeben. Demzufolge liefert der Operator <code>&amp;&amp;</code> true, wenn boolesche Werte übergeben werden und beide Operanden true sind, ansonsten false.</td> </tr> <tr> <td><code>||</code></td> <td><code>Ausdruck1 || Ausdruck2</code></td> <td>(Logisches ODER) Liefert <code>Ausdruck1</code>, wenn dieser zu true konvertiert werden kann, ansonsten wird <code>expr2</code> zurückgegeben. Demzufolge ist das Ergebnis bei <code>||</code> true, wenn boolesche Werte übergeben werden und einer dieser Werte true ist oder beide true sind. Wenn beide Operanden false sind, ist das Ergebnis false.</td> </tr> <tr> <td><code>!</code></td> <td><code>!Ausdruck</code></td> <td>(Logisches NICHT) Liefert false, wenn der (einzelne) Operand zu true umgewandelt werden kann, ansonsten wird true geliefert.</td> </tr> </tbody>
</table>
<p>Beispiele von Ausdrücken, die zu false konvertiert werden können, sind null, 0, leere Strings ("") oder undefined.</p>
<p>Der nachstehende Code zeigt Beispiele zum &amp;&amp;-Operator (logisches UND).</p>
<pre class="brush: js">var a1 =  true &amp;&amp; true;     // t &amp;&amp; t ergibt true
var a2 =  true &amp;&amp; false;    // t &amp;&amp; f ergibt false
var a3 = false &amp;&amp; true;     // f &amp;&amp; t ergibt false
var a4 = false &amp;&amp; (3 == 4); // f &amp;&amp; f ergibt false
var a5 = "Katze" &amp;&amp; "Hund";    // t &amp;&amp; t ergibt Hund
var a6 = false &amp;&amp; "Cat";    // f &amp;&amp; t ergibt false
var a7 = "Katze" &amp;&amp; false;    // t &amp;&amp; f ergibt false
</pre>
<p>Der folgende Code zeigt Beispiele zum ||-Operator (logisches ODER).</p>
<pre class="brush: js">var o1 =  true || true;     // t || t ergibt true
var o2 = false || true;     // f || t ergibt true
var o3 =  true || false;    // t || f ergibt true
var o4 = false || (3 == 4); // f || f ergibt false
var o5 = "Katze" || "Hund";    // t || t ergibt Katze
var o6 = false || "Katze";    // f || t ergibt Katze
var o7 = "Katze" || false;    // t || f ergibt Katze
</pre>
<p>Der folgende Code zeigt Beispiele zum  !-Operator (logisches NICHT).</p>
<pre class="brush: js">var n1 = !true;  // !t ergibt false
var n2 = !false; // !f ergibt true
var n3 = !"Katze"; // !t ergibt false
</pre>
<h4 name="Short-Circuit_Evaluation">Kurzschlussauswertung (Short-circuit evaluation)</h4>
<p>Logische Ausdrücke werden von links nach rechts ausgewertet und dabei auf mögliche Kurzschlussauswertungen überprüft:</p>
<ul> <li><code>false</code> &amp;&amp; <em>irgendetwas</em> ist eine Kurzschlussauswertung zu false.</li> <li><code>true</code> || <em>irgendetwas</em> ist eine Kurzschlussauswertung zu true.</li>
</ul>
<p>Wenn das Ergebnis bereits nach der Auswertung des ersten Operanden feststeht, wird der andere Teil des Ausdrucks erst gar nicht ausgewertet. Die Regeln der Logik garantieren, dass das Resultat auch dann immer korrekt ist. Da <em>irgendetwas</em> nie ausgewertet wird, kommen auch etwaige Seiteneffekte nie zur Anwendung.</p>
<h3>Zeichenkettenoperatoren (String-Operatoren)</h3>
<p>Zusätzlich zu den Vergleichsoperatoren, die auch auf String-Werte angewendet werden können, gibt es den Verbindungsoperator (+), der zwei Zeichenketten entgegen nimmt, deren Werte verbindet und als Ergebnis eine neue Zeichenkette liefert, die aus dem Verbund der beiden Zeichenketten besteht. Zum Beispiel ergibt <code>"meine " + "Zeichenkette"</code> den String<code>"meine Zeichenkette"</code>.</p>
<p>Der Operator für die Additionszuweisung  (+=) kann auch verwendet werden, um Zeichenketten zu verbinden. Wenn z.B. die Variable <code>meinString</code> den Wert "Alpha" enthält, ist das Ergebnis von<span style="font-family: monospace;"> m</span><code>einString += "bet"</code> die Zeichenkette <code>"Alphabet"</code> und diese Zeichenkette wird sogleich der Variablen<span style="font-family: monospace;"> m</span><code>einString zu</code>gewiesen.</p>
<h3>Spezielle Operatoren</h3>
<p>JavaScript stellt die folgenden speziellen Operatoren zur Verfügung:</p>
<ul> <li>{{ web.link("#Conditional_operator", "Conditional operator") }}</li> <li>{{ web.link("#Comma_operator", "Comma operator") }}</li> <li><code>{{ web.link("#delete", "delete") }}</code></li> <li><code>{{ web.link("#in", "in") }}</code></li> <li><code>{{ web.link("#instanceof", "instanceof") }}</code></li> <li><code>{{ web.link("#new", "new") }}</code></li> <li><code>{{ web.link("#this", "this") }}</code></li> <li><code>{{ web.link("#typeof", "typeof") }}</code></li> <li><code>{{ web.link("#void", "void") }}</code></li>
</ul>
<h4 name="conditional_operator">Konditionaler Operator</h4>
<p>Der konditionale Operator ist der einzige JavaScript-Operator, der drei Operanden entgegennimmt. Der Operator liefert nach der Auswertung einer Bedingung einen von zwei Werten als Ergebnis.</p>
<p>Syntax:</p>
<pre><em>Bedingung</em> ? <em>Wert1</em> : <em>Wert2</em>
</pre>
<p>Wenn die Auswertung der <code>Bedingung</code> den Wert <code>true</code> ergibt, hat der Operator den Wert von <code>Wert1</code>, andernfalls den Wert von <code>Wert2</code>. Der Operator kann überall anstatt eines Standardoperators benutzt werden. Auch anstatt von <code>if-else</code> Anweisungen kann der Operator eingesetzt werden.</p>
<p>Beispiel:</p>
<pre class="brush: js">var status = (alter &gt;= 18) ? "erwachsen" : "minderjährig";
</pre>
<p>Diese Anweisung weist der Variablen <code>status</code> den Wert <code>"erwachsen"</code> oder <code>"minderjährig"</code> zu, je nachdem ob der Wert der Variablen <code>alter</code> größer oder gleich <code>18</code> ist.</p>
<h4 name="comma_operator">Komma-Operator</h4>
<p>Der Kommaoperator (<code>,</code>) wertet einfach beide seiner Operanden (links und rechts) aus und liefert den Wert des zweiten Operanden zurück. Dieser Operator wird vorwiegend innerhalb von <code>for</code>-Schleifen benutzt, um mit mehreren Variablen innerhalb der Schleife zu arbeiten.</p>
<p>Wenn z.B. <code>a</code> ein zweidimensionales Array mit 10 Elementen auf jeder Seite ist, wird beim folgenden Code der Komma-Operator benutzt, um zwei Variablen jeweils bei einem Schleifendurchlauf zu verändern. Der Code gibt die Werte der Array-Elemente aus, die in der Diagonale stehen:</p>
<pre class="brush: js">for (var i = 0, j = 9; i &lt;= 9; i++, j--)
  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);
</pre>
<h4 name="delete"><code>delete</code></h4>
<p>Der <code>delete</code>-Operator löscht ein Objekt, eine Obejekteigenschaft oder ein Element eines spezifizierten Index in einem Array.</p>
<p>Syntax:</p>
<pre class="brush: js">delete objektName;
delete objektName.Eigenschaft;
delete objektName[Index];
delete Eigenschaft; // nur zulässig innerhalb einer with-Anweisung
</pre>
<p><code>objektName</code> ist der Name eines Objekts, <code>Eigenschaft</code> ist eine existierende Eigenschaft und <code>Index</code> eine Zahl, welche die Position eines Elements innerhalb eines Arrays angibt.</p>
<p>Die vierte Anweisung ist nur innerhalb einer <code>with</code>-Anweisung erlaubt, um eine Eigenschaft eines Objekts zu entfernen.</p>
<p>Mit dem delete-Operator kann man Variablen löschen, die implizit deklariert wurden, nicht jedoch solche, die mit <code>var</code> deklariert wurden.</p>
<p>Wenn der delete-Operator beim Löschen erfolgreich ist, setzt er die Eigenschaft oder das Element auf <code>undefined</code>. Der <code>delete</code>-Operator gibt <code>true</code> zurück, wenn die Ausführung möglich ist, ansonsten wird <code>false</code> zurückgegeben.</p>
<pre class="brush: js">x = 42;
var y = 43;
meinobj = new Number();
meinobj.h = 4;    // erzeuge Eigenschaft h
delete x;       // ergibt true (löschen funktioniert, da implizit deklariert)
delete y;       // ergibt false (löschen funktioniert nicht, weil mit var deklariert)
delete Math.PI; // ergibt false (löschen funktioniert nicht, weil vordefinierte Eigenschaft)
delete meinobj.h; // ergibt true (löschen funktioniert bei benutzerdefinierten Eigenschaften)
delete meinobj;   // ergibt true (löschen funktioniert, da implizit deklariert)
</pre>
<h5>Löschen von Array-Elementen</h5>
<p>Wenn man ein Array-Element löscht, wird die Länge des Arrays dadruch nicht beeinflusst. Zum Beispiel ist nach dem Löschen von <code>a[3]</code> das Element <code>a[4]</code> immer noch <code>a[4]</code>, jedoch ist <code>a[3]</code> nun <code>undefined</code>.</p>
<p>Wenn der <code>delete-</code>Operator ein Element entfernt, ist dieses Element nicht mehr im Array. Beim folgenden Beispiel wird <code>trees[3]</code> mit delete entfernt. Anschließend ist das Element <code>trees[3]</code> zwar noch immer addressierbar, liefert jedoch <code>undefined</code>.</p>
<pre class="brush: js">var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
if (3 in trees) {
  // wird nicht ausgeführt
}
</pre>
<p>Wenn man möchte, dass ein Array-Element zwar exisitert, aber <code>undefined</code> ist, sollte man das <code>undefined</code>-Schlüsselwort statt des delete-Operators benutzen. Beim folgenden Beispiel wird <code>trees[3]</code> der Wert <code>undefined</code> zugewiesen und das Array-Element bleibt bestehen:</p>
<pre class="brush: js">var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
if (3 in trees) {
  // wird ausgeführt
}
</pre>
<h4 name="in"><code>in</code></h4>
<p>Der <code>in</code>-Operator gibt true zurück, wenn die entsprechende Eigenschaft im angegebenen Objekt existiert.</p>
<p>Syntax:</p>
<pre class="brush: js"><em>EigenschNameOderNummer</em> in <em>objektName</em>
</pre>
<p>wobei <em>EigenschNameOderNummer</em> ein String oder ein numerischer Ausdruck sein kann, der für einen Eigenschaftsnamen oder Array-Index steht und objektName der Name eines Objekts ist.</p>
<p>Das Beispiel demonstriert die Benutzung des <code>in</code>-Operators:</p>
<pre class="brush: js">// Arrays
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
0 in trees;        // ergibt true
3 in trees;        // ergibt true
6 in trees;        // ergibt false
"bay" in trees;    // ergibt false (es muss die Index-Nummer angegeben werden,
                   // nicht der Wert)
"length" in trees; // ergibt true (length ist eine Array-Eigenschaft)

// Vordefinierte Objekte
"PI" in Math;          // ergibt true
var myString = new String("coral");
"length" in myString;  // ergibt true

// Selbstdefinierte Objekte
var mycar = {make: "Honda", model: "Accord", year: 1998};
"make" in mycar;  // ergibt true
"model" in mycar; // ergibt true
</pre>
<h4 name="instanceof"><code>instanceof</code></h4>
<p>Der <code>instanceof</code>-Operator gibt true zurück, wenn das spezifizierte Objekt vom angegebenen Typ ist.</p>
<p>Syntax:</p>
<pre class="brush: js"><em>objektName</em> instanceof <em>objektTyp</em>
</pre>
<p>wobei <code>objektName</code> der Name des Objekts ist, dessen Typ mit <code>objektTyp</code> verglichen werden soll;  <code>objektTyp</code> is ein Objekttyp, wie z.B. <code>Date</code> oder <code>Array</code>.</p>
<p>Mit <code>instanceof</code> überprüft man während der Laufzeit, ob ein Objekt von einem bestimmten Typ ist. Zum Beispiel kann man bei der Fehlerbehandlung je nach Typ unterschiedlichen Code ausführen lassen.</p>
<p>Der folgende Code greift auf <code>instanceof</code> zurück, um festzustellen, ob es sich bei <code>derTag</code> um ein <code>Date</code>-Objekt handelt und weil dies zutrifft, wird der Code der <code>if</code>-Anweisung ausgeführt.</p>
<pre class="brush: js">var theDay = new Date(1995, 12, 17);
if (theDay instanceof Date) {
  // statements to execute
}
</pre>
<h4 name="new"><code>new</code></h4>
<p>Mit dem new-Operator erzeugt man Instanzen eines benutzerdefinierten Objekts oder Instanzen von vordefinierten Objekten wie <code>Array</code>, <code>Boolean</code>, <code>Date</code>, <code>Function</code>, <code>Image</code>, <code>Number</code>, <code>Object</code>, <code>Option</code>, <code>RegExp</code>, oder <code>String</code>. Serverseitig kann er auch mit <code>DbPool</code>, <code>Lock</code>, <code>File</code>, oder <code>SendMail </code>benutzt werden.</p>
<p>Syntax:</p>
<pre class="brush: js">var <em>objektName</em> = new <em>objektTyp</em>([<em>param1</em>, <em>param2</em>, ..., <em>paramN</em>]);
</pre>
<p>Objekte kann man auch mit mit Objekt-Intializern erzeugen, wie unter {{ web.link("Working_with_objects#Using_object_initializers", "using object initializers") }} beschreiben.</p>
<p>Auf der Seite <a href="/en/JavaScript/Reference/Operators/new" title="en/Core_JavaScript_1.5_Reference/Operators/Special_Operators/new_Operator"><code>new</code> operator</a> der Core JavaScript Referenz findet man mehr Informationen.</p>
<h4 name="this"><code>this</code></h4>
<p>Mit dem Schlüsselwort <code>this</code> verweist man auf das eigene Objekt.</p>
<p><span style="color:#ff0000;">##############</span></p>
<p>Use the <code>this</code> keyword to refer to the current object. In general, <code>this</code> refers to the calling object in a method. Use <code>this</code> as follows:</p>
<pre class="brush: js">this["<em>propertyName"</em>]
</pre>
<pre class="brush: js">this.<em>propertyName</em>
</pre>
<p><strong>Example 1.</strong><br> Suppose a function called <code>validate</code> validates an object's <code>value</code> property, given the object and the high and low values:</p>
<pre class="brush: js">function validate(obj, lowval, hival){
  if ((obj.value &lt; lowval) || (obj.value &gt; hival))
    alert("Invalid Value!");
}
</pre>
<p>You could call <code>validate</code> in each form element's <code>onChange</code> event handler, using <code>this</code> to pass it the form element, as in the following example:</p>
<pre class="brush: html">&lt;B&gt;Enter a number between 18 and 99:&lt;/B&gt;
&lt;INPUT TYPE="text" NAME="age" SIZE=3
   onChange="validate(this, 18, 99);"&gt;
</pre>
<p><strong>Example 2.</strong><br> When combined with the <code>form</code> property, <code>this</code> can refer to the current object's parent form. In the following example, the form <code>myForm</code> contains a <code>Text</code> object and a button. When the user clicks the button, the value of the <code>Text</code> object is set to the form's name. The button's <code>onClick</code> event handler uses <code>this.form</code> to refer to the parent form, <code>myForm</code>.</p>
<pre class="brush: html">&lt;FORM NAME="myForm"&gt;
Form name:&lt;INPUT TYPE="text" NAME="text1" VALUE="Beluga"&gt;
&lt;P&gt;
&lt;INPUT NAME="button1" TYPE="button" VALUE="Show Form Name"
   onClick="this.form.text1.value = this.form.name;"&gt;
&lt;/FORM&gt;
</pre>
<h4 name="typeof"><code>typeof</code></h4>
<p>The <code>typeof</code> operator is used in either of the following ways:</p>
<ol> <li> <pre class="brush: js">typeof <em>operand</em>
</pre> </li> <li> <pre class="brush: js">typeof (<em>operand</em>)
</pre> </li>
</ol>
<p>The <code>typeof</code> operator returns a string indicating the type of the unevaluated operand. <code>operand</code> is the string, variable, keyword, or object for which the type is to be returned. The parentheses are optional.</p>
<p>Suppose you define the following variables:</p>
<pre class="brush: js">var myFun = new Function("5 + 2");
var shape = "round";
var size = 1;
var today = new Date();
</pre>
<p>The <code>typeof</code> operator returns the following results for these variables:</p>
<pre class="brush: js">typeof myFun;     // returns "function"
typeof shape;     // returns "string"
typeof size;      // returns "number"
typeof today;     // returns "object"
typeof dontExist; // returns "undefined"
</pre>
<p>For the keywords <code>true</code> and <code>null</code>, the <code>typeof</code> operator returns the following results:</p>
<pre class="brush: js">typeof true; // returns "boolean"
typeof null; // returns "object"
</pre>
<p>For a number or string, the <code>typeof</code> operator returns the following results:</p>
<pre class="brush: js">typeof 62;            // returns "number"
typeof 'Hello world'; // returns "string"
</pre>
<p>For property values, the <code>typeof</code> operator returns the type of value the property contains:</p>
<pre class="brush: js">typeof document.lastModified; // returns "string"
typeof window.length;         // returns "number"
typeof Math.LN2;              // returns "number"
</pre>
<p>For methods and functions, the <code>typeof</code> operator returns results as follows:</p>
<pre class="brush: js">typeof blur;        // returns "function"
typeof eval;        // returns "function"
typeof parseInt;    // returns "function"
typeof shape.split; // returns "function"
</pre>
<p>For predefined objects, the <code>typeof</code> operator returns results as follows:</p>
<pre class="brush: js">typeof Date;     // returns "function"
typeof Function; // returns "function"
typeof Math;     // returns "object"
typeof Option;   // returns "function"
typeof String;   // returns "function"
</pre>
<h4 name="void"><code>void</code></h4>
<p>The <code>void</code> operator is used in either of the following ways:</p>
<ol> <li> <pre class="brush: js">void (<em>expression</em>)
</pre> </li> <li> <pre class="brush: js">void <em>expression</em>
</pre> </li>
</ol>
<p>The <code>void</code> operator specifies an expression to be evaluated without returning a value. <code>expression</code> is a JavaScript expression to evaluate. The parentheses surrounding the expression are optional, but it is good style to use them.</p>
<p>You can use the <code>void</code> operator to specify an expression as a hypertext link. The expression is evaluated but is not loaded in place of the current document.</p>
<p>The following code creates a hypertext link that does nothing when the user clicks it. When the user clicks the link, <code>void(0)</code> evaluates to undefined, which has no effect in JavaScript.</p>
<pre class="brush: html">&lt;A HREF="javascript:void(0)"&gt;Click here to do nothing&lt;/A&gt;
</pre>
<p>The following code creates a hypertext link that submits a form when the user clicks it.</p>
<pre class="brush: html">&lt;A HREF="javascript:void(document.form.submit())"&gt;
Click here to submit&lt;/A&gt;
</pre>
<h3>Operator precedence</h3>
<p>The <em>precedence</em> of operators determines the order they are applied when evaluating an expression. You can override operator precedence by using parentheses.</p>
<p>The following table describes the precedence of operators, from highest to lowest.</p>
<p><small><em>In accordance with <a href="/Talk:en/JavaScript/Guide/Obsolete_Pages/Operators#Precedence_Table" title="Talk:en/Core_JavaScript_1.5_Guide/Operators#Precedence_Table">relevant discussion</a>, this table was reversed to list operators in <strong>decreasing</strong> order of priority.</em></small></p>
<table class="standard-table"> <caption style="text-align: left;">Table 3.7 Operator precedence</caption> <thead> <tr> <th scope="col">Operator type</th> <th scope="col">Individual operators</th> </tr> </thead> <tbody> <tr> <td>member</td> <td><code>.  []</code></td> </tr> <tr> <td>call / create instance</td> <td><code>()  new</code></td> </tr> <tr> <td>negation/increment</td> <td><code>!  ~  -  +  ++  --  typeof  void  delete</code></td> </tr> <tr> <td>multiply/divide</td> <td><code>*  /  %</code></td> </tr> <tr> <td>addition/subtraction</td> <td><code>+  -</code></td> </tr> <tr> <td>bitwise shift</td> <td><code>&lt;&lt;  &gt;&gt;  &gt;&gt;&gt;</code></td> </tr> <tr> <td>relational</td> <td><code>&lt;  &lt;=  &gt;  &gt;=  in  instanceof</code></td> </tr> <tr> <td>equality</td> <td><code>==  !=  ===  !==</code></td> </tr> <tr> <td>bitwise-and</td> <td><code>&amp;</code></td> </tr> <tr> <td>bitwise-xor</td> <td><code>^</code></td> </tr> <tr> <td>bitwise-or</td> <td><code>|</code></td> </tr> <tr> <td>logical-and</td> <td><code>&amp;&amp;</code></td> </tr> <tr> <td>logical-or</td> <td><code>||</code></td> </tr> <tr> <td>conditional</td> <td><code>?:</code></td> </tr> <tr> <td>assignment</td> <td><code>=  +=  -=  *=  /=  %=  &lt;&lt;=  &gt;&gt;=  &gt;&gt;&gt;=  &amp;=  ^=  |=</code></td> </tr> <tr> <td>comma</td> <td><code>,</code></td> </tr> </tbody>
</table>
<p>A more detailed version of this table, complete with links to additional details about each operator, may be found in <a href="/en/JavaScript/Reference/Operators/Operator_Precedence#Table" title="en/Core_JavaScript_1.5_Reference/Operators/Operator_Precedence#Table">JavaScript Reference</a>.</p>
<pre class="script" style="font-size: 16px;">autoPreviousNext("JSGChapters");
</pre>
Zu dieser Version zurücksetzen