Exponentiation (\*\*)
=====================

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.

Try it
------

Syntax
------


```js
x \*\* y
```

Description
-----------

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.

Examples
--------

### Basic exponentiation


```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
```

### Associativity


```js
2 \*\* 3 \*\* 2; // 512
2 \*\* (3 \*\* 2); // 512
(2 \*\* 3) \*\* 2; // 64
```

### Usage with unary operators

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
```

Specifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-exp-operator |

Browser compatibility
---------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* Addition (`+`)
* Subtraction (`-`)
* Division (`/`)
* Multiplication (`*`)
* Remainder (`%`)
* Increment (`++`)
* Decrement (`--`)
* Unary negation (`-`)
* Unary plus (`+`)