Exponentiation (**) — Operator · JavaScript-Referenz

Signatur

x ** y

Beschreibung

Der Exponentiationsoperator ** (doppeltes Sternchen) erhebt die Basis (linker Operand) zur Potenz (rechter Operand) und gibt das numerische Ergebnis zurück. Er ist die kompakte, lesbare Alternative zu Math.pow(x, y) und wurde mit ECMAScript 2016 (ES7) eingeführt.

Der Operator ist rechts-assoziativ: Bei einer Kette wie 2 ** 3 ** 2 wird zunächst 3 ** 2 = 9 berechnet und dann 2 ** 9 = 512 — also von rechts nach links. Das unterscheidet ihn von den meisten anderen arithmetischen Operatoren, die links-assoziativ sind.

Wichtig bei negativen Basen: Ein unäres Minus direkt vor der Basis ohne Klammern führt zu einem SyntaxError. Korrekte Schreibweise ist daher (-2) ** 3. Operanden vom Typ BigInt werden unterstützt, allerdings darf der Exponent bei BigInt nicht negativ sein, da sonst ein RangeError geworfen wird.

Basis ist NaN → Ergebnis ist NaN (Ausnahme: NaN ** 0 === 1)
Exponent ist 0 → Ergebnis ist immer 1, auch für 0 ** 0
Basis ist Infinity → Ergebnis ist Infinity (positiver Exponent) oder 0 (negativer Exponent)

Parameter

Name	Typ	Default	Beschreibung
$x Pflicht	number \| bigint	—	Die Basis — der Wert, der potenziert wird. Kann eine Zahl oder ein `BigInt` sein.
$y Pflicht	number \| bigint	—	Der Exponent — die Potenz, auf die die Basis erhoben wird. Bei `BigInt`-Operanden muss dieser Wert `>= 0` sein.

Rückgabewert

Typ

number | bigint

Beschreibung

Das Ergebnis von x hoch y. Der Typ entspricht dem Typ der Operanden (number oder bigint). Beide Operanden müssen denselben Typ haben.

Beispiele

Grundlegende Verwendung

console.log(2 ** 10);   // 2 hoch 10
console.log(3 ** 3);    // 3 hoch 3
console.log(9 ** 0.5);  // Quadratwurzel aus 9
console.log(2 ** -2);   // Negativer Exponent → Kehrwert

1024 27 3 0.25

Rechts-Assoziativität beachten

// Rechts-assoziativ: 3 ** 2 = 9, dann 2 ** 9 = 512
console.log(2 ** 3 ** 2);

// Mit Klammern erzwungene Links-Assoziativität:
console.log((2 ** 3) ** 2);

512 64

Negative Basis korrekt klammern

// SyntaxError: -2 ** 2  ← nicht erlaubt
// Korrekt: Basis in Klammern setzen
console.log((-2) ** 3);  // negative Basis
console.log((-2) ** 2);  // gerades Ergebnis → positiv

-8 4

Verwendung mit BigInt

const basis = 2n;
const exponent = 64n;
console.log(basis ** exponent); // Sehr große Ganzzahl, kein Präzisionsverlust

18446744073709551616n

Zuweisung mit **= (Exponentiation Assignment)

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

81

Vergleich mit Math.pow()

const basis = 5;
const exp = 3;

// Klassisch:
console.log(Math.pow(basis, exp));

// Modern mit **:
console.log(basis ** exp);

125 125

// Wichtig · Fallstricke

SyntaxError bei unärem Minus: Der Ausdruck -x ** y ist ohne Klammern absichtlich verboten, um Mehrdeutigkeiten zu vermeiden (ist es (-x) ** y oder -(x ** y)?). Immer explizit klammern: (-x) ** y.

Browser-Kompatibilität: Der Operator ** ist seit ES2016 Bestandteil des Standards und wird von allen modernen Browsern (Chrome 52+, Firefox 52+, Safari 10.1+, Edge 14+) sowie Node.js ab Version 7 nativ unterstützt. Für ältere Umgebungen kann Babel den Operator auf Math.pow() transpilieren.

Besondere Werte:

NaN ** 0 === 1 (Ausnahme von der NaN-Propagation)
0 ** 0 === 1 (mathematische Konvention)
Infinity ** 0 === 1
(-1) ** Infinity === NaN

BigInt-Einschränkung: Ein negativer Exponent bei BigInt-Werten (z. B. 2n ** -1n) wirft einen RangeError, da BigInt keine Bruchzahlen darstellen kann.

Siehe auch

Math.pow() Math.sqrt() Arithmetische Operatoren **= BigInt NaN