Ausdrücke und Operatoren

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 arithmetische Operatoren benutzt.)
String: liefern eine Zeichenkette, z.B. "Fred" oder "234". (Grundsätzlich werden String-Operatoren benutzt.)
Logisch: liefern true oder false. (Oft werden Logische Operatoren verwendet.)
Objekt: liefern ein Objekt. (Siehe 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.

Zuweisungsoperatoren
Vergleichsoperatoren
Arithmetische Operatoren
Bitweise Operatoren
Logische Operatoren
Zeichenkettenoperatoren
Spezielle Operatoren

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 (132 + 016 + 08 + 14 + 02 + 01 = 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 (12 + 01 = 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 (14 + 02 + 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:

Konditionaler Operator
Komma-Operator
delete
in
instanceof
new
this
typeof
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 Objekt-Intializern erzeugen, wie unter Benutzung von Objekt-Literalen beschreiben.

Auf der Seite new-Operator der JavaScript-Referenz findet man mehr Informationen.

`this`

Mit dem Schlüsselwort this wird auf das aktuelle Objekt verwiesen. Im Allgemeinen steht this für das aufrufende Objekt in einer Methode.

Syntax:

this["propertyName"]

this.propertyName

Beispiel 1.
Angenommen eine Funktion validieren validiert die Eigenschaft value eines Objekts, wobei ihr das Objekt und zwei Werte übergeben werden:

function validieren(obj, lowval, hival){
  if ((obj.value < lowval) || (obj.value > hival))
    alert("Falscher Wert!");
}

Dann könnte validieren für jedes Formelement über den Event-Handler onChange aufgerufen werden, indem mit this auf dieses Formelement verwiesen wird:

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

Beispiel 2.

Kombiniert mit den Eigenschaften von form kann this auf das Eltern-Formular des aktuellen Objekts verweisen. Beim folgenden Beispiel enthält das Formular myForm ein Text-Objekt und einen Button. Wenn der Benutzer den Button anklickt, wird der Wert des Objekts Text als Name für des Formulars festgelegt. Beim onClick-Eventhandler des Buttons wird this.form benutzt, um auf das Elternformular myForm zu verweisen.

<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`

Der typeof-Operator kann auf zwei verschiedene Arten benutzt werden:

```
typeof operand
```
```
typeof (operand)
```

Der typeof-Operator gibt einen String mit der Bezeichung für den Typ des übergebenen Operanden zurück. Der Operand kann ein String, eine Variable, ein Schlüsselwort oder ein Objekt sein. Die Klammern sind optional.

Angenommen es werden die folgenden Variablen definiert:

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

Dann liefert der typeof-Operator folgende Ergbnisse:

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

Für die Schlüsselwörter true und null liefert der typeof-Operator die folgenden Ergebnisse:

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

Für eine Zahl oder einen String liefert typeof-Operator die folgenden Ergbnisse:

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

Für Eigenschaftswerte liefert der typeof-Operator den Typ des Wertes, welcher der Eigenschaft zugewiesen ist:

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

Für Methoden und Funktionen liefert der typeof-Operator die folgenden Ergebnisse:

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

Für vordefinierte Objekte liefert der typeof-Operator die folgenden Ergebnisse:

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

`void`

Der void-Operator kann auf zwei verschiedene Arten benutzt werden:

```
void (Ausdruck)
```
```
void Ausdruck
```

Der void-Operator spezifiziert einen Ausdruck, ohne dass ein Wert zurückgegeben wird. Ausdruck ist ein JavaScript-Ausdruck. Die Klammern sind optional, aber es ist guter Stil diese einzusetzen.

Mit dem void-Operator kann ein Ausdruck als Hyperlink verwendet werden. Der Ausdruck wird dann ausgewertet, jedoch nicht an der Stelle des Dokuments geladen.

Mit folgendem Code wird ein ein Hyperlink erstellt, der nichts bewirkt, wenn der Benutzer ihn anklickt. Wenn der Benutzer den Link anklickt, evaluiert void(0) zu indefined, was bei Javascript keinen Effekt hat.

<A HREF="javascript:void(0)">Hier klicken damit nichts passiert</A>

Im nächsten Beispiel wird ein Formualr gesendet, wenn der Benutzer den Link anklickt.

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

Operatorenreihenfolge

Die Reihenfolge der Operatoren bestimmt, welche Operatoren eines Ausdrucks zuerst ausgewertet werden. Die Reihenfolge der Auswertung kann mit Hilfe von Klammern beeinflusst werden.

Die folgende Tabelle beschreibt die Reihefolge der Operatoren.

In Übereinstimmung mit einer Diskussion, wurde diese Tabelle so verändert, dass der Operator mit der höchsten Priorität zuerst und der Operator mit der niedrigsten Priorität am Ende der Tabelle steht.

Table 3.7 Operatorenreihenfolge
Operator-Typ	zugehörige Operatoren
Mitglied	`. []`
Aufruf/Instanzierung	`() new`
Negation/Inkrementierung	`! ~ - + ++ -- typeof void delete`
Multiplikation/Division/Modulo	`* / %`
Addition/Subtraktion	`+ -`
Bitwise Verschiebung	`<< >> >>>`
Relation	`< <= > >= in instanceof`
Gleichheit	`== != === !==`
Bitweises UND	`&`
Bitweises XODER	`^`
Bitweises ODER	`\|`
Logisches UND	`&&`
Logisches ODER	`\|\|`
Konditional	`?:`
Zuweisung	`= += -= *= /= %= <<= >>= >>>= &= ^= \|=`
Komma	`,`

Eine detailliertere Version dieser Tabelle, komplett mit Links und detaillieter Beschreibung der einzelnen Operatoren, findet man in der JavaScript-Referenz.