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