mozilla
Ihre Suchergebnisse

    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:

    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.

    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:

    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:

    Enter a number between 18 and 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: 
     

    typeof

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

    1. typeof operand
    2. 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:

    1. void (Ausdruck)
    2. 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.

    Hier klicken damit nichts passiert
    

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

    
    Click here to submit

    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.

    </form>

    Schlagwörter des Dokuments und Mitwirkende

    Schlagwörter: 
    Mitwirkende an dieser Seite: eminor, DavidWalsh, fscholz
    Zuletzt aktualisiert von: fscholz,