The **exponentiation (`**`

)** operator returns the result of raising the first operand to the power of the second operand. It is equivalent to `Math.pow()`

, except it also accepts BigInts as operands.

The **exponentiation (`**`

)** operator returns the result of raising the first operand to the power of the second operand. It is equivalent to `Math.pow()`

, except it also accepts BigInts as operands.

js

```
x ** y
```

The `**`

operator is overloaded for two types of operands: number and BigInt. It first coerces both operands to numeric values and tests the types of them. It performs BigInt exponentiation if both operands become BigInts; otherwise, it performs number exponentiation. A `TypeError`

is thrown if one operand becomes a BigInt but the other becomes a number.

For both numbers and BigInts, `0`

raised to a positive power returns `0`

, and `0`

raised to a power of `0`

returns `1`

. For numbers, `0`

raised to a negative number returns `Infinity`

, while `-0`

raised to a negative number returns `-Infinity`

.

`NaN ** 0`

(and the equivalent `Math.pow(NaN, 0)`

) is the only case where `NaN`

doesn't propagate through mathematical operations — it returns `1`

despite the operand being `NaN`

. In addition, the behavior where `base`

is 1 and `exponent`

is non-finite (±Infinity or `NaN`

) is different from IEEE 754, which specifies that the result should be 1, whereas JavaScript returns `NaN`

to preserve backward compatibility with its original behavior.

For BigInt exponentiation, a `RangeError`

is thrown if the exponent `y`

is negative. This is because any negative exponent would likely result in a value between 0 and 1 (unless the base is `1`

, `-1`

, or `0`

), which is rounded to zero, and is likely a developer mistake.

The exponentiation operator is right-associative: `a ** b ** c`

is equal to `a ** (b ** c)`

.

In most languages, such as PHP, Python, and others that have an exponentiation operator (`**`

), the exponentiation operator is defined to have a higher precedence than unary operators, such as unary `+`

and unary `-`

, but there are a few exceptions. For example, in Bash, the `**`

operator is defined to have a lower precedence than unary operators.

In JavaScript, it is impossible to write an ambiguous exponentiation expression. That is, you cannot put a unary operator (with precedence 14, including `+`

/`-`

/`~`

/`!`

/`++`

/`--`

/`delete`

/`void`

/`typeof`

/`await`

) immediately before the base number; doing so will cause a SyntaxError.

For example, `-2 ** 2`

is 4 in Bash, but is -4 in other languages (such as Python). This is invalid in JavaScript, as the operation is ambiguous. You have to parenthesize either side — for example, as `-(2 ** 2)`

— to make the intention unambiguous.

Note that some programming languages use the caret symbol `^`

for exponentiation, but JavaScript uses that symbol for the bitwise XOR operator.

js

2 ** 3; // 8 3 ** 2; // 9 3 ** 2.5; // 15.588457268119896 10 ** -1; // 0.1 2 ** 1024; // Infinity NaN ** 2; // NaN NaN ** 0; // 1 1 ** Infinity; // NaN 2n ** 3n; // 8n 2n ** 1024n; // A very large number, but not Infinity 2n ** 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions // To do exponentiation with a BigInt and a non-BigInt, convert either operand 2n ** BigInt(2); // 4n Number(2n) ** 2; // 4

js

2 ** 3 ** 2; // 512 2 ** (3 ** 2); // 512 (2 ** 3) ** 2; // 64

To invert the sign of the result of an exponentiation expression:

js

-(2 ** 2); // -4

To force the base of an exponentiation expression to be a negative number:

js

(-2) ** 2; // 4

Specification |
---|

ECMAScript Language Specification # sec-exp-operator |

Desktop | Mobile | Server | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|

Chrome | Edge | Firefox | Opera | Safari | Chrome Android | Firefox for Android | Opera Android | Safari on IOS | Samsung Internet | WebView Android | Deno | Node.js | ||

`Exponentiation` |
52 | 14 | 52 | 39 | 10.1 | 52 | 52 | 41 | 10.3 | 6.0 | 51 | 1.0 | 7.0.0 |

© 2005–2023 MDN contributors.

Licensed under the Creative Commons Attribution-ShareAlike License v2.5 or later.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Exponentiation