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.
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:
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.
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).
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:
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:
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.
let a = 1;
a++++; // SyntaxError: Invalid left-hand side in postfix operation.
Die Operatorpriorität wird rekursiv berücksichtigt. Betrachten Sie beispielsweise diesen Ausdruck:
1 + 2 ** 3 * 4 / 5 >> 6
Zunächst gruppieren wir Operatoren mit unterschiedlicher Priorität in absteigender Reihenfolge ihrer Priorität.
- Der Operator
**hat die höchste Priorität und wird daher zuerst gruppiert. - 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. - Bei Betrachtung der in Schritt 2 gebildeten
*//-Gruppe wird+vor>>gruppiert, da+eine höhere Priorität hat.
(1 + ( (2 ** 3) * 4 / 5) ) >> 6
// │ │ └─ 1. ─┘ │ │
// │ └────── 2. ───────┘ │
// └────────── 3. ──────────┘
Innerhalb der *//-Gruppe wird aufgrund der Linksassoziativität beider Operatoren zuerst der linke Operand gruppiert.
(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.
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 (?.).
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:
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:
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:
- 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. - 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. - 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 accessx.y |
[2] |
Optional chainingx?.y |
|||
| nicht zutreffend |
Computed member accessx[y]
|
[3] | |
new mit Argumentlistenew x(y) |
[4] | ||
Funktionsaufrufx(y)
|
|||
import(x) |
|||
| 16: new | nicht zutreffend | new ohne Argumentlistenew x |
|
| 15: Postfixoperatoren | nicht zutreffend |
Postfix incrementx++
|
[5] |
Postfix decrementx--
|
|||
| 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 |
Exponentiationx ** y
|
[8] |
| 12: multiplikative Operatoren | von links nach rechts |
Multiplicationx * y
|
|
Divisionx / y
|
|||
Remainderx % y
|
|||
| 11: additive Operatoren | von links nach rechts |
Additionx + y
|
|
Subtractionx - y
|
|||
| 10: bitweise Verschiebung | von links nach rechts |
Left shiftx << y
|
|
Right shiftx >> y
|
|||
Unsigned right shiftx >>> y
|
|||
| 9: Vergleichsoperatoren | von links nach rechts |
Less thanx < y
|
|
Less than or equalx <= y
|
|||
Greater thanx > y
|
|||
Greater than or equalx >= y
|
|||
x in y |
|||
x instanceof y |
|||
| 8: Gleichheitsoperatoren | von links nach rechts |
Equalityx == y
|
|
Inequalityx != y
|
|||
Strict equalityx === y
|
|||
Strict inequalityx !== y
|
|||
| 7: bitweises UND | von links nach rechts |
Bitwise ANDx & y
|
|
| 6: bitweises XOR | von links nach rechts |
Bitwise XORx ^ y
|
|
| 5: bitweises ODER | von links nach rechts |
Bitwise ORx | y
|
|
| 4: logisches UND | von links nach rechts |
Logical ANDx && y
|
|
| 3: logisches ODER, Nullish Coalescing | von links nach rechts |
Logical ORx || y
|
|
Nullish coalescing operatorx ?? y
|
[9] | ||
| 2: Zuweisung und Sonstiges | von rechts nach links |
Assignmentx = y
|
[10] |
Addition assignmentx += y
|
|||
Subtraction assignmentx -= y
|
|||
Exponentiation assignmentx **= y
|
|||
Multiplication assignmentx *= y
|
|||
Division assignmentx /= y
|
|||
Remainder assignmentx %= y
|
|||
Left shift assignmentx <<= y
|
|||
Right shift assignmentx >>= y
|
|||
Unsigned right shift assignmentx >>>= y
|
|||
Bitwise AND assignmentx &= y
|
|||
Bitwise XOR assignmentx ^= y
|
|||
Bitwise OR assignmentx |= y
|
|||
Logical AND assignmentx &&= y
|
|||
Logical OR assignmentx ||= y
|
|||
Nullish coalescing assignmentx ??= y
|
|||
| von rechts nach links |
Bedingter (ternärer) Operatorx ? y : z
|
[11] | |
| von rechts nach links |
Arrowx => y
|
[12] | |
| nicht zutreffend | yield x |
||
yield* x |
|||
Spread...x
|
[13] | ||
| 1: Komma | von links nach rechts |
Comma operatorx, y
|
Hinweise:
- Der Operand kann ein beliebiger Ausdruck sein.
- Die „rechte Seite“ muss ein Bezeichner sein.
- Die „rechte Seite“ kann ein beliebiger Ausdruck sein.
- 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. - 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 nichtnew (Foo++)(ein TypeError: (Foo++) ist kein Konstruktor). - Der Operand muss ein gültiges Zuweisungsziel sein (ein Bezeichner oder ein Property-Zugriff).
- Der Operand darf weder ein Bezeichner noch ein Zugriff auf ein privates Element sein.
- Die linke Seite darf keine Priorität von 14 haben, ausgenommen Präfix-Inkrementierung und Präfix-Dekrementierung.
- Die Operanden dürfen ohne Gruppierung keine Operatoren für logisches ODER
||oder logisches UND&&sein. - Die „linke Seite“ muss ein gültiges Zuweisungsziel sein (ein Bezeichner oder ein Property-Zugriff).
- Die Assoziativität bewirkt, dass die beiden Ausdrücke nach
?implizit gruppiert werden. - Die „linke Seite“ ist ein einzelner Bezeichner oder eine eingeklammerte Parameterliste.
- 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?.bzulässig ist, ist beispielsweise aucha.bzulässig und umgekehrt. Dasselbe gilt entsprechend füra?.()unda()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,
newmit Argumenten, Funktionsaufruf undnewohne Argumente.- Die „linke Seite“ eines Member-Zugriffs kann Folgendes sein: ein Member-Zugriff (
a.b.c),newmit Argumenten (new a().b) oder ein Funktionsaufruf (a().b). - Die „linke Seite“ von
newmit Argumenten kann Folgendes sein: ein Member-Zugriff (new a.b()) odernewmit Argumenten (new new a()()). - Die „linke Seite“ eines Funktionsaufrufs kann Folgendes sein: ein Member-Zugriff (
a.b()),newmit Argumenten (new a()()) oder ein Funktionsaufruf (a()()). - Der Operand von
newohne Argumente kann Folgendes sein: ein Member-Zugriff (new a.b),newmit Argumenten (new new a()) odernewohne Argumente (new new a).
- Die „linke Seite“ eines Member-Zugriffs kann Folgendes sein: ein Member-Zugriff (