Exponentialer Zuweisungsoperator (**=) — Operator · JavaScript-Referenz

Signatur

x **= y

Beschreibung

Der Operator **= ist eine Kurzschreibweise für x = x ** y. Er kombiniert den Exponentiierungsoperator (**) mit der Zuweisung und erlaubt es, eine Variable direkt mit einer Potenz zu überschreiben, ohne sie zweimal nennen zu müssen.

Die Exponentiierung berechnet x hoch y, also x^y. Intern ruft JavaScript Math.pow(x, y) auf — das Ergebnis ist jedoch in allen modernen Engines identisch. Der linke Operand muss eine gültige Zuweisungsziel-Variable (oder Eigenschaft) sein; ein Literal wie 2 **= 3 erzeugt einen ReferenceError.

Wichtig: Auf der linken Seite eines unären Operators darf ** (und damit auch **=) nicht direkt ohne Klammern stehen. -2 ** 2 ist ein Syntaxfehler — stattdessen muss man (-2) ** 2 schreiben. Dieser Schutz verhindert Mehrdeutigkeiten beim Vorzeichen.

Geeignet für kompakten mathematischen Code (Simulationen, Grafik, Kryptographie).
Operiert auf number- und bigint-Werten (beide Seiten müssen denselben Typ haben).
Gibt NaN zurück, wenn ein Operand kein sinnvoller numerischer Wert ist.

Parameter

Name	Typ	Default	Beschreibung
$x Pflicht	number \| bigint	—	Die Basis — eine Variable oder Objekteigenschaft, die den Ausgangswert enthält und das Ergebnis aufnimmt.
$y Pflicht	number \| bigint	—	Der Exponent — der Wert, mit dem `x` potenziert wird.

Rückgabewert

Typ

number | bigint

Beschreibung

Das Ergebnis von x ** y, gleichzeitig der neue Wert von x.

Beispiele

Einfache Potenzierung mit **=

let basis = 3;
basis **= 4;          // entspricht: basis = basis ** 4
console.log(basis);   // 81

let flaeche = 5;
flaeche **= 2;        // Fläche eines Quadrats mit Seite 5
console.log(flaeche); // 25

81 25

Verwendung mit BigInt

let big = 2n;
big **= 64n;
console.log(big); // 18446744073709551616n  (2^64 als BigInt)

18446744073709551616n

Exponentielles Wachstum berechnen

// Zinseszins-Berechnung: Kapital nach n Jahren
const berechneKapital = (startKapital, zinssatz, jahre) => {
  let kapital = startKapital;
  const wachstumsFaktor = 1 + zinssatz / 100;
  // Wachstumsfaktor wird auf 'jahre' Perioden potenziert
  let faktor = wachstumsFaktor;
  faktor **= jahre;
  kapital *= faktor;
  return kapital.toFixed(2);
};

console.log(berechneKapital(1000, 5, 10)); // 1000 € bei 5% über 10 Jahre

1628.89

Fallstrick: Negativer Basiswert erfordert Klammern

// Syntaxfehler — direkt an einen unären Operator darf ** nicht grenzen:
// let x = -2;
// x **= 2;  // OK, da x eine Variable ist

// Aber Vorsicht bei Ausdrücken:
const ergebnis = (-3) ** 2;  // Korrekt: 9
console.log(ergebnis);

// NaN-Verhalten:
let wert = 'hallo';
wert **= 2;
console.log(wert); // NaN

9 NaN

// Wichtig · Fallstricke

Browser-Kompatibilität: **= ist seit ES2016 standardisiert und wird von allen modernen Browsern sowie Node.js ab Version 7 unterstützt. Internet Explorer unterstützt den Operator nicht.

Typsicherheit: Das Mischen von number und bigint (z. B. 2n **= 3 auf der linken Seite mit einer number rechts) wirft einen TypeError. Beide Seiten müssen denselben primitiven Typ haben.

Sonderfälle:

x **= 0 ergibt immer 1 (auch 0 **= 0 === 1).
x **= 0.5 entspricht der Quadratwurzel von x (wie Math.sqrt(x)).
Infinity **= 2 ergibt Infinity.
Negative Exponenten sind erlaubt: 2 **= -1 ergibt 0.5.

Siehe auch

Exponentiierungsoperator (**) Multiplikativer Zuweisungsoperator (*=) Math.pow() Additiver Zuweisungsoperator (+=) Zuweisungsoperator (=)