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

Für die obige Kombination gibt es zwei mögliche Interpretationen:

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

Welche davon 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 berücksichtigt; die Assoziativität spielt dabei keine Rolle. Die Multiplikation hat beispielsweise eine höhere Priorität als die Addition und wird zuerst ausgeführt, 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 anhand 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);

Das erwartete Ergebnis ist, dass a und b den Wert 5 erhalten. 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 andere arithmetische 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 zunächst nach Priorität gruppiert. Benachbarte Operatoren mit derselben Priorität werden anschließend nach Assoziativität gruppiert. Werden Division und Potenzierung kombiniert, kommt die Potenzierung daher immer vor der Division. Beispielsweise ergibt 2 ** 3 / 3 ** 2 den Wert 0.8888888888888888, da dies (2 ** 3) / (3 ** 2) entspricht.

Nehmen wir für unäre Präfixoperatoren folgendes Muster an:

OP1 a OP2 b

Dabei ist OP1 ein unärer Präfixoperator und OP2 ein binärer Operator. Hat OP1 eine höhere Priorität als OP2, 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 der unäre Operator vor dem zweiten Operanden steht:

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. Das folgende Beispiel ist ungültig:

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

Da + eine höhere Priorität als yield hat, würde daraus (a + yield) 1. Weil 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, sodass dieses Problem bei ihnen nicht auftritt.

Wenn zwei unäre Präfixoperatoren vorliegen:

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 die Gruppierung (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 wird new !A; zu (new !) A, da ! eine niedrigere Priorität als new hat. Das ist offensichtlich ungültig. (Ohnehin wäre dieser Code wenig sinnvoll, da !A immer einen booleschen Wert und keine Konstruktorfunktion erzeugt.)

Für unäre Postfixoperatoren (++ und --) gelten dieselben Regeln. Glücklicherweise haben beide Operatoren eine höhere Priorität als jeder binäre Operator, sodass die Gruppierung stets der Erwartung entspricht. Da ++ außerdem einen Wert und keine Referenz ergibt, können auch nicht mehrere Inkrementierungen aneinandergereiht werden.

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

Zunächst 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. Links vom Ausdruck mit ** steht +, rechts davon *. Da * eine höhere Priorität hat, wird es zuerst gruppiert. * und / haben dieselbe Priorität, daher fassen wir sie zunächst zu einer Gruppe zusammen.
  3. Bei Betrachtung der in Schritt 2 gebildeten *//-Gruppe wird + vor >> gruppiert, da + eine höhere Priorität hat.
js
   (1 + ( (2 ** 3) * 4 / 5) ) >> 6
// │    │ └─ 1. ─┘        │ │
// │    └────── 2. ───────┘ │
// └────────── 3. ──────────┘

Innerhalb der *//-Gruppe wird aufgrund der Linksassoziativität beider Operatoren 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 (die implizite Gruppierung) beeinflussen, 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 miteinander 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

Falls 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 (in diesem Fall /). Zuerst wird der linke Operand dieses Operators ausgewertet. Er kann wiederum Operatoren mit höherer Priorität enthalten, etwa einen Funktionsaufruf echo("left", 4). Danach wird der rechte Operand auf dieselbe Weise ausgewertet. Daher werden alle Blattknoten – die echo()-Aufrufe – von links nach rechts besucht, unabhängig von der Priorität der Operatoren, die sie miteinander verbinden.

Kurzschlussauswertung

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

Kurzschlussauswertung bezeichnet die bedingte Auswertung. Ist beispielsweise bei a && (b + c) der Wert von a falsy, wird der Teilausdruck (b + c) gar nicht ausgewertet, obwohl er gruppiert ist und damit eine höhere Priorität als && hat. Man sagt, dass beim logischen UND-Operator (&&) eine Kurzschlussauswertung stattfindet. Weitere Operatoren mit Kurzschlussauswertung sind das logische ODER (||), Nullish Coalescing (??) und Optional Chaining (?.).

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 Kurzschlussauswertung wird der linke Operand immer ausgewertet. Der rechte Operand wird nur dann ausgewertet, wenn der linke Operand das Ergebnis der Operation nicht bereits bestimmt.

Hinweis: Die Kurzschlussauswertung ist eine Eigenschaft dieser Operatoren. Andere Operatoren werten immer beide Operanden aus, unabhängig davon, ob dies tatsächlich nützlich ist. Beispielsweise ruft NaN * foo() stets foo auf, obwohl das Ergebnis nur NaN sein kann.

Das zuvor beschriebene Modell der Postorder-Traversierung gilt weiterhin. Nachdem der linke Teilbaum eines Operators mit Kurzschlussauswertung besucht wurde, entscheidet die Sprache jedoch, ob der rechte Operand ausgewertet werden muss. Falls nicht – beispielsweise 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

Obwohl && eine höhere Priorität hat, wird nur C() ausgewertet. Das bedeutet nicht, dass || hier eine höhere Priorität hätte. Gerade weil (B() && A()) eine höhere Priorität hat, wird dieser Ausdruck als Ganzes übersprungen. Wird der Ausdruck wie folgt umgestellt:

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

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

Beachten Sie jedoch, dass die Kurzschlussauswertung das endgültige Auswertungsergebnis nicht verändert. Sie beeinflusst lediglich 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 bei den entsprechenden Zuweisungsoperatoren (&&=, ||=, ??=) findet eine Kurzschlussauswertung statt. Dabei kann die Zuweisung vollständig ausbleiben.

Tabelle

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

Einige allgemeine Hinweise zur Tabelle:

  1. Nicht jede hier aufgeführte Syntax ist im engeren Sinne ein „Operator“. 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 manchen 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-Zugriffs . (Priorität 17) ein Bezeichner sein und darf kein gruppierter Ausdruck sein. Die linke Seite von Arrow => (Priorität 2) muss eine Argumentliste oder ein einzelner Bezeichner sein und darf nicht irgendein Ausdruck sein.
  3. Bei manchen Operatoren dürfen bestimmte Operanden weiter gefasste Ausdrücke sein, als Operatoren mit höherer Priorität erzeugen. Beispielsweise darf der in eckigen Klammern stehende Ausdruck der Klammernotation [ … ] (Priorität 17) ein beliebiger Ausdruck sein, auch ein durch Kommas verknüpfter Ausdruck (Priorität 1). Diese Operatoren verhalten sich so, als wäre der betreffende Operand „automatisch gruppiert“. In solchen Fällen lassen wir die Angabe zur 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: Postfixoperatoren nicht zutreffend Postfix increment
x++
[5]
Postfix decrement
x--
14: Präfixoperatoren 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: Vergleichsoperatoren 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 Kommaausdrücke). Der Konstruktor eines new-Ausdrucks darf kein Optional Chain sein.
  5. Der Operand muss ein gültiges Zuweisungsziel sein (ein Bezeichner oder ein Property-Zugriff). Aufgrund seiner Priorität bedeutet new Foo++ dasselbe wie (new Foo)++ (ein Syntaxfehler) und nicht new (Foo++) (ein TypeError: (Foo++) ist kein Konstruktor).
  6. Der Operand muss ein gültiges Zuweisungsziel sein (ein Bezeichner oder ein Property-Zugriff).
  7. Der Operand darf weder ein Bezeichner noch ein Zugriff auf ein privates Element sein.
  8. Die linke Seite darf keine Priorität von 14 haben, ausgenommen Präfix-Inkrementierung und Präfix-Dekrementierung.
  9. Die Operanden dürfen ohne Gruppierung keine Operatoren für logisches ODER || oder logisches UND && sein.
  10. Die „linke Seite“ muss ein gültiges Zuweisungsziel sein (ein Bezeichner oder ein Property-Zugriff).
  11. Die Assoziativität bewirkt, 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 zulässig.

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

  • Optional Chaining kann stets anstelle der entsprechenden Syntax ohne Optionalität verwendet werden und umgekehrt (abgesehen von einigen Sonderfällen, in denen Optional Chaining nicht zulässig ist). Überall, wo a?.b zulässig ist, ist beispielsweise auch a.b zulässig und umgekehrt. Dasselbe gilt entsprechend für a?.() und a() usw.
  • Member-Ausdrücke und berechnete Member-Ausdrücke können stets gegeneinander ausgetauscht werden.
  • Aufrufausdrücke und import()-Ausdrücke können stets gegeneinander ausgetauscht werden.
  • Damit bleiben vier Ausdrucksklassen: Member-Zugriff, new mit Argumenten, Funktionsaufruf und new ohne Argumente.
    • Die „linke Seite“ eines Member-Zugriffs kann Folgendes sein: ein Member-Zugriff (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-Zugriff (new a.b()) oder new mit Argumenten (new new a()()).
    • Die „linke Seite“ eines Funktionsaufrufs kann Folgendes sein: ein Member-Zugriff (a.b()), new mit Argumenten (new a()()) oder ein Funktionsaufruf (a()()).
    • Der Operand von new ohne Argumente kann Folgendes sein: ein Member-Zugriff (new a.b), new mit Argumenten (new new a()) oder new ohne Argumente (new new a).