Ausdrücke und Operatoren

  • Adressname der Version: JavaScript/javascript_guide/Ausdrücke_und_Operatoren
  • Titel der Version: Ausdrücke und Operatoren
  • ID der Version: 265366
  • Erstellt:
  • Autor: eminor
  • Aktuelle Version? Nein
  • Kommentar 2 words added, 4 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 Audsruck, der x den Wert 7 zuweist und gleichzeitig liefert dieser Ausdruck selbst den Wert 7 zurück. Diese Art von Ausdrücke 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", "special operators") }} für diverse Ausdrücke, die Objekte liefern.)

Operatoren

JavaScript kennt die folgenden Typen von 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 weißt x den Wert von y zu.

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

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) vergleichen. 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. Das heißt sie vergleichen nicht nur, ob der Wert der Operanden übereinstimmt sondern auch, ob es sich um denselben Datentyp handelt; auch versuchen diese Operatoren 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 im Bezug auf den folgenden Code:

var var1 = 3, var2 = 4;
Table 3.2 Comparison operators
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 (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 ganzahligen Restwert der Division der beiden Operanden. 12 % 5 ergibt 2.
++
(Inkrement)
Unärer Operator. Addiert eins zum Operanden. Wenn er als Prefix-Operator verwendet, d.h. dem Operanden vorangestellt wird (++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 Opertor hintangestellt (x++), wird der Operanden 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, nur wird subtrahiert statt addiert. 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 veranschaulicht 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 (0*1 + 0*2 + 1*4 + 0*8 + 0*16 + 1*32 = 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 lieferder 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 Zeichenketten verbindet und als Ergebnis eine neue Zeichenkette liefert. 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 dieses Ergebnis wird gleich der Variablen meinString zugewiesen.

Special operators

JavaScript provides the following special operators:

  • {{ 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") }}

Conditional operator

The conditional operator is the only JavaScript operator that takes three operands. The operator can have one of two values based on a condition. The syntax is:

condition ? val1 : val2

If condition is true, the operator has the value of val1. Otherwise it has the value of val2. You can use the conditional operator anywhere you would use a standard operator.

For example,

var status = (age >= 18) ? "adult" : "minor";

This statement assigns the value "adult" to the variable status if age is eighteen or more. Otherwise, it assigns the value "minor" to status.

Comma operator

The comma operator (,) simply evaluates both of its operands and returns the value of the second operand. This operator is primarily used inside a for loop, to allow multiple variables to be updated each time through the loop.

For example, if a is a 2-dimensional array with 10 elements on a side, the following code uses the comma operator to increment two variables at once. The code prints the values of the diagonal elements in the array:

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

delete

The delete operator deletes an object, an object's property, or an element at a specified index in an array. The syntax is:

delete objectName;
delete objectName.property;
delete objectName[index];
delete property; // legal only within a with statement

where objectName is the name of an object, property is an existing property, and index is an integer representing the location of an element in an array.

The fourth form is legal only within a with statement, to delete a property from an object.

You can use the delete operator to delete variables declared implicitly but not those declared with the var statement.

If the delete operator succeeds, it sets the property or element to undefined. The delete operator returns true if the operation is possible; it returns false if the operation is not possible.

x = 42;
var y = 43;
myobj = new Number();
myobj.h = 4;    // create property h
delete x;       // returns true (can delete if declared implicitly)
delete y;       // returns false (cannot delete if declared with var)
delete Math.PI; // returns false (cannot delete predefined properties)
delete myobj.h; // returns true (can delete user-defined properties)
delete myobj;   // returns true (can delete if declared implicitly)
Deleting array elements

When you delete an array element, the array length is not affected. For example, if you delete a[3], a[4] is still a[4] and a[3] is undefined.

When the delete operator removes an array element, that element is no longer in the array. In the following example, trees[3] is removed with delete. However, trees[3] is still addressable and returns undefined.

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
if (3 in trees) {
  // this does not get executed
}

If you want an array element to exist but have an undefined value, use the undefined keyword instead of the delete operator. In the following example, trees[3] is assigned the value undefined, but the array element still exists:

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
if (3 in trees) {
  // this gets executed
}

in

The in operator returns true if the specified property is in the specified object. The syntax is:

propNameOrNumber in objectName

where propNameOrNumber is a string or numeric expression representing a property name or array index, and objectName is the name of an object.

The following examples show some uses of the in operator.

// Arrays
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
0 in trees;        // returns true
3 in trees;        // returns true
6 in trees;        // returns false
"bay" in trees;    // returns false (you must specify the index number,
                   // not the value at that index)
"length" in trees; // returns true (length is an Array property)

// Predefined objects
"PI" in Math;          // returns true
var myString = new String("coral");
"length" in myString;  // returns true

// Custom objects
var mycar = {make: "Honda", model: "Accord", year: 1998};
"make" in mycar;  // returns true
"model" in mycar; // returns true

instanceof

The instanceof operator returns true if the specified object is of the specified object type. The syntax is:

objectName instanceof objectType

where objectName is the name of the object to compare to objectType, and objectType is an object type, such as Date or Array.

Use instanceof when you need to confirm the type of an object at runtime. For example, when catching exceptions, you can branch to different exception-handling code depending on the type of exception thrown.

For example, the following code uses instanceof to determine whether theDay is a Date object. Because theDay is a Date object, the statements in the if statement execute.

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

new

You can use the new operator to create an instance of a user-defined object type or of one of the predefined object types Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp, or String. On the server, you can also use it with DbPool, Lock, File, or SendMail. Use new as follows:

var objectName = new objectType([param1, param2, ..., paramN]);

You can also create objects using object initializers, as described in {{ web.link("Working_with_objects#Using_object_initializers", "using object initializers") }}. 

See the new operator page in the Core JavaScript Reference for more information.

this

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 Audsruck, der x den Wert <code>7</code> zuweist und gleichzeitig liefert dieser Ausdruck selbst den Wert 7 zurück. Diese Art von Ausdrücke 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", "special operators") }} für diverse Ausdrücke, die Objekte liefern.)</li>
</ul><h2>Operatoren</h2>
<p>JavaScript kennt die folgenden Typen von 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.</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 weißt x den Wert von y zu.</p>
<p>Die anderen Zuweisungsoperatoren sind eine Kurzschreibweise für Standardoperationen. Die nachstehende Tabelle zeigt deren Bedeutung auf:</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) vergleichen. 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. Das heißt sie vergleichen nicht nur, ob der Wert der Operanden übereinstimmt sondern auch, ob es sich um denselben Datentyp handelt; auch versuchen diese Operatoren 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 im Bezug auf den folgenden Code:</p>
<pre class="brush: js">var var1 = 3, var2 = 4;
</pre>
<table class="standard-table"> <caption style="text-align: left;">Table 3.2 Comparison operators</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 (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 ganzahligen 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 Prefix-Operator verwendet, d.h. dem Operanden vorangestellt wird (<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 Opertor hintangestellt (<code>x++</code>), wird der Operanden 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, nur wird subtrahiert statt addiert.</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 veranschaulicht 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 (0*1 + 0*2 + 1*4 + 0*8 + 0*16 + 1*32 = 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 lieferder 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 Zeichenketten verbindet und als Ergebnis eine neue Zeichenkette liefert. 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 <code>meinString += "bet"</code> die Zeichenkette "Alphabet" und dieses Ergebnis wird gleich der Variablen <code>meinString zu</code>gewiesen.</p><h3>Special operators</h3>
<p>JavaScript provides the following special operators:</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">Conditional operator</h4>
<p>The conditional operator is the only JavaScript operator that takes three operands. The operator can have one of two values based on a condition. The syntax is:</p>
<pre><em>condition</em> ? <em>val1</em> : <em>val2</em>
</pre>
<p>If <code>condition</code> is true, the operator has the value of <code>val1</code>. Otherwise it has the value of <code>val2</code>. You can use the conditional operator anywhere you would use a standard operator.</p>
<p>For example,</p>
<pre class="brush: js">var status = (age &gt;= 18) ? "adult" : "minor";
</pre>
<p>This statement assigns the value "adult" to the variable <code>status</code> if <code>age</code> is eighteen or more. Otherwise, it assigns the value "minor" to <code>status</code>.</p>
<h4 name="comma_operator">Comma operator</h4>
<p>The comma operator (<code>,</code>) simply evaluates both of its operands and returns the value of the second operand. This operator is primarily used inside a <code>for</code> loop, to allow multiple variables to be updated each time through the loop.</p>
<p>For example, if <code>a</code> is a 2-dimensional array with 10 elements on a side, the following code uses the comma operator to increment two variables at once. The code prints the values of the diagonal elements in the array:</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>The <code>delete</code> operator deletes an object, an object's property, or an element at a specified index in an array. The syntax is:</p>
<pre class="brush: js">delete objectName;
delete objectName.property;
delete objectName[index];
delete property; // legal only within a with statement
</pre>
<p>where <code>objectName</code> is the name of an object, <code>property</code> is an existing property, and <code>index</code> is an integer representing the location of an element in an array.</p>
<p>The fourth form is legal only within a <code>with</code> statement, to delete a property from an object.</p>
<p>You can use the <code>delete</code> operator to delete variables declared implicitly but not those declared with the <code>var</code> statement.</p>
<p>If the <code>delete</code> operator succeeds, it sets the property or element to <code>undefined</code>. The <code>delete</code> operator returns true if the operation is possible; it returns false if the operation is not possible.</p>
<pre class="brush: js">x = 42;
var y = 43;
myobj = new Number();
myobj.h = 4;    // create property h
delete x;       // returns true (can delete if declared implicitly)
delete y;       // returns false (cannot delete if declared with var)
delete Math.PI; // returns false (cannot delete predefined properties)
delete myobj.h; // returns true (can delete user-defined properties)
delete myobj;   // returns true (can delete if declared implicitly)
</pre>
<h5>Deleting array elements</h5>
<p>When you delete an array element, the array length is not affected. For example, if you delete <code>a[3]</code>, <code>a[4]</code> is still <code>a[4]</code> and <code>a[3]</code> is undefined.</p>
<p>When the <code>delete</code> operator removes an array element, that element is no longer in the array. In the following example, <code>trees[3]</code> is removed with <code>delete</code>. However, <code>trees[3]</code> is still addressable and returns <code>undefined</code>.</p>
<pre class="brush: js">var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
if (3 in trees) {
  // this does not get executed
}
</pre>
<p>If you want an array element to exist but have an undefined value, use the <code>undefined</code> keyword instead of the <code>delete</code> operator. In the following example, <code>trees[3]</code> is assigned the value <code>undefined</code>, but the array element still exists:</p>
<pre class="brush: js">var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
if (3 in trees) {
  // this gets executed
}
</pre>
<h4 name="in"><code>in</code></h4>
<p>The <code>in</code> operator returns true if the specified property is in the specified object. The syntax is:</p>
<pre class="brush: js"><em>propNameOrNumber</em> in <em>objectName</em>
</pre>
<p>where <code>propNameOrNumber</code> is a string or numeric expression representing a property name or array index, and <code>objectName</code> is the name of an object.</p>
<p>The following examples show some uses of the <code>in</code> operator.</p>
<pre class="brush: js">// Arrays
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
0 in trees;        // returns true
3 in trees;        // returns true
6 in trees;        // returns false
"bay" in trees;    // returns false (you must specify the index number,
                   // not the value at that index)
"length" in trees; // returns true (length is an Array property)

// Predefined objects
"PI" in Math;          // returns true
var myString = new String("coral");
"length" in myString;  // returns true

// Custom objects
var mycar = {make: "Honda", model: "Accord", year: 1998};
"make" in mycar;  // returns true
"model" in mycar; // returns true
</pre>
<h4 name="instanceof"><code>instanceof</code></h4>
<p>The <code>instanceof</code> operator returns true if the specified object is of the specified object type. The syntax is:</p>
<pre class="brush: js"><em>objectName</em> instanceof <em>objectType</em>
</pre>
<p>where <code>objectName</code> is the name of the object to compare to <code>objectType</code>, and <code>objectType</code> is an object type, such as <code>Date</code> or <code>Array</code>.</p>
<p>Use <code>instanceof</code> when you need to confirm the type of an object at runtime. For example, when catching exceptions, you can branch to different exception-handling code depending on the type of exception thrown.</p>
<p>For example, the following code uses <code>instanceof</code> to determine whether <code>theDay</code> is a <code>Date</code> object. Because <code>theDay</code> is a <code>Date</code> object, the statements in the <code>if</code> statement execute.</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>You can use the <code>new</code> operator to create an instance of a user-defined object type or of one of the predefined object types <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>, or <code>String</code>. On the server, you can also use it with <code>DbPool</code>, <code>Lock</code>, <code>File</code>, or <code>SendMail</code>. Use <code>new</code> as follows:</p>
<pre class="brush: js">var <em>objectName</em> = new <em>objectType</em>([<em>param1</em>, <em>param2</em>, ..., <em>paramN</em>]);
</pre>
<p>You can also create objects using object initializers, as described in {{ web.link("Working_with_objects#Using_object_initializers", "using object initializers") }}. </p>
<p>See the <a href="/en/JavaScript/Reference/Operators/new" title="en/Core_JavaScript_1.5_Reference/Operators/Special_Operators/new_Operator"><code>new</code> operator</a> page in the Core JavaScript Reference for more information.</p>
<h4 name="this"><code>this</code></h4>
<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