Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.

View in English Always switch to English

Operatorpriorität

Die Operatorpriorität bestimmt, wie Operatoren im Verhältnis zueinander geparst werden. Operatoren mit höherer Priorität werden zu Operanden von Operatoren mit niedrigerer Priorität.

Probieren Sie es aus

console.log(3 + 4 * 5); // 3 + 20
// Expected output: 23

console.log(4 * 3 ** 2); // 4 * 9
// Expected output: 36

let a;
let b;

console.log((a = b = 5));
// Expected output: 5

Priorität und Assoziativität

Betrachten Sie einen Ausdruck, der sich durch die folgende Darstellung beschreiben lässt. Dabei stehen OP1 und OP2 jeweils als Platzhalter für Operatoren.

a OP1 b OP2 c

Die obige Kombination lässt sich auf zwei Arten interpretieren:

(a OP1 b) OP2 c
a OP1 (b OP2 c)

Welche Interpretation die Sprache verwendet, hängt davon ab, welche Operatoren OP1 und OP2 sind.

Wenn OP1 und OP2 unterschiedliche Prioritätsstufen haben (siehe die Tabelle unten), wird der Operator mit der höheren Priorität zuerst gruppiert; die Assoziativität spielt dann keine Rolle. Beachten Sie, dass die Multiplikation eine höhere Priorität als die Addition hat und zuerst ausgeführt wird, obwohl die Addition im Code zuerst steht.

js
console.log(3 + 10 * 2); // 23
console.log(3 + (10 * 2)); // 23, because parentheses here are superfluous
console.log((3 + 10) * 2); // 26, because the parentheses change the order

Operatoren mit derselben Priorität gruppiert die Sprache nach ihrer Assoziativität. Linksassoziativität (von links nach rechts) bedeutet, dass der Ausdruck als (a OP1 b) OP2 c interpretiert wird; Rechtsassoziativität (von rechts nach links) bedeutet, dass er als a OP1 (b OP2 c) interpretiert wird. Zuweisungsoperatoren sind rechtsassoziativ. Daher können Sie Folgendes schreiben:

js
a = b = 5; // same as writing a = (b = 5);

Wie erwartet erhalten dabei a und b den Wert 5. Das liegt daran, dass der Zuweisungsoperator den zugewiesenen Wert zurückgibt. Zuerst wird b auf 5 gesetzt. Anschließend wird auch a auf 5 gesetzt – auf den Rückgabewert von b = 5, also den rechten Operanden der Zuweisung.

Ein weiteres Beispiel ist der Potenzierungsoperator: Er ist rechtsassoziativ, während die anderen arithmetischen Operatoren linksassoziativ sind.

js
const a = 4 ** 3 ** 2; // Same as 4 ** (3 ** 2); evaluates to 262144
const b = 4 / 3 / 2; // Same as (4 / 3) / 2; evaluates to 0.6666...

Operatoren werden zuerst nach ihrer Priorität gruppiert. Benachbarte Operatoren mit derselben Priorität werden anschließend nach ihrer Assoziativität gruppiert. Wenn Division und Potenzierung kombiniert werden, wird die Potenzierung daher immer vor der Division gruppiert. Beispielsweise ergibt 2 ** 3 / 3 ** 2 den Wert 0.8888888888888888, da dies (2 ** 3) / (3 ** 2) entspricht.

Nehmen wir für vorangestellte unäre Operatoren das folgende Muster an:

OP1 a OP2 b

Dabei ist OP1 ein vorangestellter unärer Operator und OP2 ein binärer Operator. Wenn OP1 eine höhere Priorität als OP2 hat, wird der Ausdruck als (OP1 a) OP2 b gruppiert; andernfalls als OP1 (a OP2 b).

js
const a = 1;
const b = 2;
typeof a + b; // Equivalent to (typeof a) + b; result is "number2"

Wenn sich der unäre Operator auf den zweiten Operanden bezieht:

a OP2 OP1 b

Dann muss der binäre Operator OP2 eine niedrigere Priorität als der unäre Operator OP1 haben, damit der Ausdruck als a OP2 (OP1 b) gruppiert wird. Beispielsweise ist Folgendes ungültig:

js
function* foo() {
  a + yield 1;
}

Da + eine höhere Priorität als yield hat, würde daraus (a + yield) 1. Da yield in Generatorfunktionen jedoch ein reserviertes Wort ist, führt dies zu einem Syntaxfehler. Glücklicherweise haben die meisten unären Operatoren eine höhere Priorität als binäre Operatoren und sind von diesem Problem nicht betroffen.

Wenn wir zwei vorangestellte unäre Operatoren haben:

OP1 OP2 a

Dann muss der näher am Operanden stehende unäre Operator OP2 eine höhere Priorität als OP1 haben, damit der Ausdruck als OP1 (OP2 a) gruppiert wird. Andernfalls kann stattdessen (OP1 OP2) a entstehen:

js
async function* foo() {
  await yield 1;
}

Da await eine höhere Priorität als yield hat, würde daraus (await yield) 1. Dabei würde auf einen Bezeichner namens yield gewartet, was zu einem Syntaxfehler führt. Ähnlich verhält es sich mit new !A;: Da ! eine niedrigere Priorität als new hat, würde daraus (new !) A, was offensichtlich ungültig ist. (Diesen Code zu schreiben wäre ohnehin wenig sinnvoll, da !A immer einen booleschen Wert und keine Konstruktorfunktion erzeugt.)

Für nachgestellte unäre Operatoren, nämlich ++ und --, gelten dieselben Regeln. Glücklicherweise haben beide Operatoren eine höhere Priorität als jeder binäre Operator, sodass die Gruppierung immer den Erwartungen entspricht. Da ++ außerdem zu einem Wert und nicht zu einer Referenz ausgewertet wird, können Sie auch nicht mehrere Inkrementierungen aneinanderhängen.

js
let a = 1;
a++++; // SyntaxError: Invalid left-hand side in postfix operation.

Die Operatorpriorität wird rekursiv berücksichtigt. Betrachten Sie beispielsweise diesen Ausdruck:

js
1 + 2 ** 3 * 4 / 5 >> 6

Zuerst gruppieren wir Operatoren mit unterschiedlicher Priorität in absteigender Reihenfolge ihrer Priorität.

  1. Der Operator ** hat die höchste Priorität und wird daher zuerst gruppiert.
  2. Neben dem Ausdruck mit ** steht rechts * und links +. Da * eine höhere Priorität hat, wird es zuerst gruppiert. * und / haben dieselbe Priorität, daher fassen wir sie zunächst zusammen.
  3. Neben dem in Schritt 2 zusammengefassten Ausdruck mit * und / stehen + und >>. Da + eine höhere Priorität als >> hat, wird + zuerst gruppiert.
js
   (1 + ( (2 ** 3) * 4 / 5) ) >> 6
// │    │ └─ 1. ─┘        │ │
// │    └────── 2. ───────┘ │
// └────────── 3. ──────────┘

Innerhalb der Gruppe mit * und / wird wegen ihrer Linksassoziativität zuerst der linke Operand gruppiert.

js
   (1 + ( ( (2 ** 3) * 4 ) / 5) ) >> 6
// │    │ │ └─ 1. ─┘     │    │ │
// │    └─│─────── 2. ───│────┘ │
// └──────│───── 3. ─────│──────┘
//        └───── 4. ─────┘

Beachten Sie, dass Operatorpriorität und Assoziativität nur die Auswertungsreihenfolge der Operatoren beeinflussen, also die implizite Gruppierung, nicht aber die Auswertungsreihenfolge der Operanden. Die Operanden werden immer von links nach rechts ausgewertet. Ausdrücke mit höherer Priorität werden zuerst ausgewertet; ihre Ergebnisse werden anschließend entsprechend der Operatorpriorität verknüpft.

js
function echo(name, num) {
  console.log(`Evaluating the ${name} side`);
  return num;
}
// Exponentiation operator (**) is right-associative,
// but all call expressions (echo()), which have higher precedence,
// will be evaluated before ** does
console.log(echo("left", 4) ** echo("middle", 3) ** echo("right", 2));
// Evaluating the left side
// Evaluating the middle side
// Evaluating the right side
// 262144

// Exponentiation operator (**) has higher precedence than division (/),
// but evaluation always starts with the left operand
console.log(echo("left", 4) / echo("middle", 3) ** echo("right", 2));
// Evaluating the left side
// Evaluating the middle side
// Evaluating the right side
// 0.4444444444444444

Wenn Sie mit Binärbäumen vertraut sind, können Sie sich dies als Postorder-Traversierung vorstellen.

                /
       ┌────────┴────────┐
echo("left", 4)         **
                ┌────────┴────────┐
        echo("middle", 3)  echo("right", 2)

Nachdem alle Operatoren korrekt gruppiert wurden, bilden die binären Operatoren einen Binärbaum. Die Auswertung beginnt bei der äußersten Gruppe – also beim Operator mit der niedrigsten Priorität (hier /). Zuerst wird der linke Operand dieses Operators ausgewertet. Er kann Ausdrücke mit höherer Priorität enthalten, etwa einen Funktionsaufruf wie echo("left", 4). Danach wird der rechte Operand auf dieselbe Weise ausgewertet. Somit werden alle Blattknoten – die Aufrufe von echo() – unabhängig von der Priorität der sie verbindenden Operatoren von links nach rechts besucht.

Kurzschlussauswertung

Im vorherigen Abschnitt hieß es, dass „Ausdrücke mit höherer Priorität immer zuerst ausgewertet werden“. Das gilt im Allgemeinen, muss aber um die Kurzschlussauswertung ergänzt werden: Bei ihr wird ein Operand unter Umständen überhaupt nicht ausgewertet.

Kurzschlussauswertung bezeichnet die bedingte Auswertung. Wenn beispielsweise im Ausdruck a && (b + c) der Wert von a falsy ist, wird der Teilausdruck (b + c) gar nicht ausgewertet – obwohl er gruppiert ist und damit eine höhere Priorität als && hat. Man sagt, dass der logische UND-Operator (&&) „kurzschließt“. Neben dem logischen UND verwenden auch das logische ODER (||), Nullish Coalescing (??) und Optional Chaining (?.) eine Kurzschlussauswertung.

js
a || (b * c); // evaluate `a` first, then produce `a` if `a` is "truthy"
a && (b < c); // evaluate `a` first, then produce `a` if `a` is "falsy"
a ?? (b || c); // evaluate `a` first, then produce `a` if `a` is not `null` and not `undefined`
a?.b.c; // evaluate `a` first, then produce `undefined` if `a` is `null` or `undefined`

Bei der Auswertung eines Operators mit Kurzschlussverhalten wird der linke Operand immer ausgewertet. Der rechte Operand wird nur ausgewertet, wenn der linke Operand das Ergebnis der Operation nicht bereits bestimmt.

Hinweis: Das Kurzschlussverhalten ist Bestandteil dieser Operatoren. Andere Operatoren werten immer beide Operanden aus, unabhängig davon, ob das sinnvoll ist. Beispielsweise ruft NaN * foo() immer foo auf, obwohl das Ergebnis in jedem Fall NaN ist.

Das zuvor beschriebene Modell einer Postorder-Traversierung gilt weiterhin. Nachdem jedoch der linke Teilbaum eines Operators mit Kurzschlussverhalten besucht wurde, entscheidet die Sprache, ob der rechte Operand ausgewertet werden muss. Falls nicht – etwa weil der linke Operand von || bereits truthy ist –, wird das Ergebnis direkt zurückgegeben, ohne den rechten Teilbaum zu besuchen.

Betrachten Sie diesen Fall:

js
function A() { console.log('called A'); return false; }
function B() { console.log('called B'); return false; }
function C() { console.log('called C'); return true; }

console.log(C() || B() && A());

// Logs:
// called C
// true

Nur C() wird ausgewertet, obwohl && eine höhere Priorität hat. Das bedeutet nicht, dass || in diesem Fall eine höhere Priorität hat. Gerade weil (B() && A()) eine höhere Priorität hat, kann es als Ganzes übersprungen werden. Wird der Ausdruck wie folgt umgestellt:

js
console.log(A() && B() || C());
// Logs:
// called A
// called C
// true

Dann verhindert die Kurzschlussauswertung von && lediglich, dass B() ausgewertet wird. Da A() && B() insgesamt false ergibt, wird C() dennoch ausgewertet.

Beachten Sie jedoch, dass die Kurzschlussauswertung das endgültige Ergebnis nicht verändert. Sie beeinflusst nur die Auswertung der Operanden, nicht die Gruppierung der Operatoren. Wenn die Auswertung der Operanden keine Seiteneffekte hat – etwa Ausgaben in der Konsole, Zuweisungen an Variablen oder das Auslösen eines Fehlers –, ist die Kurzschlussauswertung überhaupt nicht zu beobachten.

Auch die entsprechenden Zuweisungsoperatoren (&&=, ||=, ??=) verwenden eine Kurzschlussauswertung. Dabei kann die Zuweisung vollständig ausbleiben.

Tabelle

Die folgende Tabelle führt die Operatoren in der Reihenfolge von der höchsten Priorität (18) bis zur niedrigsten Priorität (1) auf.

Einige allgemeine Hinweise zur Tabelle:

  1. Nicht alle hier aufgeführten Syntaxformen sind „Operatoren“ im engeren Sinne. Beispielsweise gelten Spread ... und Arrow => üblicherweise nicht als Operatoren. Sie sind dennoch aufgeführt, um zu zeigen, wie stark sie im Vergleich zu anderen Operatoren und Ausdrücken binden.
  2. Bei einigen Operatoren müssen bestimmte Operanden enger gefasste Ausdrücke sein, als Operatoren mit höherer Priorität erzeugen. Beispielsweise muss die rechte Seite des Member Access . (Priorität 17) ein Bezeichner und kein gruppierter Ausdruck sein. Die linke Seite von Arrow => (Priorität 2) muss eine Argumentliste oder ein einzelner Bezeichner sein und darf kein beliebiger Ausdruck sein.
  3. Bei einigen Operatoren dürfen bestimmte Operanden weiter gefasste Ausdrücke sein, als Operatoren mit höherer Priorität erzeugen. Beispielsweise kann der in eckigen Klammern stehende Ausdruck der Bracket Notation [ … ] (Priorität 17) ein beliebiger Ausdruck sein, auch einer, der durch den Kommaoperator (Priorität 1) verknüpft ist. Diese Operatoren verhalten sich so, als wäre der betreffende Operand „automatisch gruppiert“. In solchen Fällen lassen wir die Assoziativität weg.
Priorität Assoziativität Einzelne Operatoren Hinweise
18: Gruppierung nicht zutreffend Grouping
(x)
[1]
17: Zugriff und Aufruf von links nach rechts Member access
x.y
[2]
Optional chaining
x?.y
nicht zutreffend Computed member access
x[y]
[3]
new mit Argumentliste
new x(y)
[4]
Funktionsaufruf
x(y)
import(x)
16: new nicht zutreffend new ohne Argumentliste
new x
15: nachgestellte Operatoren nicht zutreffend Postfix increment
x++
[5]
Postfix decrement
x--
14: vorangestellte Operatoren nicht zutreffend Prefix increment
++x
[6]
Prefix decrement
--x
Logical NOT
!x
Bitwise NOT
~x
Unary plus
+x
Unary negation
-x
typeof x
void x
delete x [7]
await x
13: Potenzierung von rechts nach links Exponentiation
x ** y
[8]
12: multiplikative Operatoren von links nach rechts Multiplication
x * y
Division
x / y
Remainder
x % y
11: additive Operatoren von links nach rechts Addition
x + y
Subtraction
x - y
10: bitweise Verschiebung von links nach rechts Left shift
x << y
Right shift
x >> y
Unsigned right shift
x >>> y
9: relationale Operatoren von links nach rechts Less than
x < y
Less than or equal
x <= y
Greater than
x > y
Greater than or equal
x >= y
x in y
x instanceof y
8: Gleichheitsoperatoren von links nach rechts Equality
x == y
Inequality
x != y
Strict equality
x === y
Strict inequality
x !== y
7: bitweises UND von links nach rechts Bitwise AND
x & y
6: bitweises XOR von links nach rechts Bitwise XOR
x ^ y
5: bitweises ODER von links nach rechts Bitwise OR
x | y
4: logisches UND von links nach rechts Logical AND
x && y
3: logisches ODER, Nullish Coalescing von links nach rechts Logical OR
x || y
Nullish coalescing operator
x ?? y
[9]
2: Zuweisung und Sonstiges von rechts nach links Assignment
x = y
[10]
Addition assignment
x += y
Subtraction assignment
x -= y
Exponentiation assignment
x **= y
Multiplication assignment
x *= y
Division assignment
x /= y
Remainder assignment
x %= y
Left shift assignment
x <<= y
Right shift assignment
x >>= y
Unsigned right shift assignment
x >>>= y
Bitwise AND assignment
x &= y
Bitwise XOR assignment
x ^= y
Bitwise OR assignment
x |= y
Logical AND assignment
x &&= y
Logical OR assignment
x ||= y
Nullish coalescing assignment
x ??= y
von rechts nach links Bedingter (ternärer) Operator
x ? y : z
[11]
von rechts nach links Arrow
x => y
[12]
nicht zutreffend yield x
yield* x
Spread
...x
[13]
1: Komma von links nach rechts Comma operator
x, y

Hinweise:

  1. Der Operand kann ein beliebiger Ausdruck sein.
  2. Die „rechte Seite“ muss ein Bezeichner sein.
  3. Die „rechte Seite“ kann ein beliebiger Ausdruck sein.
  4. Die „rechte Seite“ ist eine durch Kommas getrennte Liste beliebiger Ausdrücke mit einer Priorität > 1 (also keine durch den Kommaoperator verknüpften Ausdrücke). Der Konstruktor eines Ausdrucks mit new darf kein Optional Chain sein.
  5. Der Operand muss ein gültiges Zuweisungsziel sein (ein Bezeichner oder ein Property Access). Aufgrund seiner Priorität bedeutet new Foo++ dasselbe wie (new Foo)++ (ein Syntaxfehler) und nicht new (Foo++) (ein TypeError: (Foo++) is not a constructor).
  6. Der Operand muss ein gültiges Zuweisungsziel sein (ein Bezeichner oder ein Property Access).
  7. Der Operand darf kein Bezeichner und kein Zugriff auf ein privates Element sein.
  8. Die linke Seite darf nicht die Priorität 14 haben, außer bei vorangestellter Inkrementierung und Dekrementierung.
  9. Ohne Gruppierung dürfen die Operanden keine Ausdrücke mit dem logischen ODER-Operator || oder dem logischen UND-Operator && sein.
  10. Die „linke Seite“ muss ein gültiges Zuweisungsziel sein (ein Bezeichner oder ein Property Access).
  11. Die Assoziativität bedeutet, dass die beiden Ausdrücke nach ? implizit gruppiert werden.
  12. Die „linke Seite“ ist ein einzelner Bezeichner oder eine eingeklammerte Parameterliste.
  13. Nur innerhalb von Objektliteralen, Array-Literalen oder Argumentlisten gültig.

Die Priorität der Gruppen 17 und 16 kann etwas mehrdeutig erscheinen. Die folgenden Beispiele verdeutlichen sie.

  • Optional Chaining lässt sich immer durch die entsprechende Syntax ohne Optionalität ersetzen und umgekehrt (abgesehen von einigen Sonderfällen, in denen Optional Chaining nicht zulässig ist). Beispielsweise sind an jeder Stelle, an der a?.b zulässig ist, auch a.b und umgekehrt zulässig. Entsprechendes gilt für a?.() und a() usw.
  • Member Expressions und Computed Member Expressions sind immer gegeneinander austauschbar.
  • Call Expressions und import()-Ausdrücke sind immer gegeneinander austauschbar.
  • Damit bleiben vier Klassen von Ausdrücken: Member Access, new mit Argumenten, Funktionsaufruf und new ohne Argumente.
    • Die „linke Seite“ eines Member Access kann Folgendes sein: ein Member Access (a.b.c), new mit Argumenten (new a().b) oder ein Funktionsaufruf (a().b).
    • Die „linke Seite“ von new mit Argumenten kann Folgendes sein: ein Member Access (new a.b()) oder new mit Argumenten (new new a()()).
    • Die „linke Seite“ eines Funktionsaufrufs kann Folgendes sein: ein Member Access (a.b()), new mit Argumenten (new a()()) oder ein Funktionsaufruf (a()()).
    • Der Operand von new ohne Argumente kann Folgendes sein: ein Member Access (new a.b), new mit Argumenten (new new a()) oder new ohne Argumente (new new a).