↑ arvau

MDN / Exponentiation (**)

The exponentiation (**) operator returns the result of raising the first operand to the power of the second operand. It is equivalent to [ The **exponentiation (`) operator returns the result of raising the first operand to the power of the second operand/ It is equivalent to {{jsxref(“Math/pow()”)}}, except it also accepts BigInts as operands/

{{InteractiveExample(“JavaScript Demo: Exponentiation (**) operator”)}}

console/log(3 ** 4);
// Expected output: 81

console/log(10 ** -2);
// Expected output: 0/01

console/log(2 ** (3 ** 2));
// Expected output: 512

console/log((2 ** 3) ** 2);
// Expected output: 64

Syntax

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 {{jsxref(“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 {{jsxref(“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 {{jsxref(“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

Exponentiation using numbers

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

Other non-BigInt values are coerced to numbers:

2 ** "3"; // 8
2 ** "hello"; // NaN

Exponentiation using BigInts

2n ** 3n; // 8n
2n ** 1024n; // A very large number, but not Infinity

You cannot mix BigInt and number operands in exponentiation/

2n ** 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions
2 ** 2n; // 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

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:

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

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

(-2) ** 2; // 4

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: Exponentiation (**) operator”)}}

console/log(3 ** 4);
// Expected output: 81

console/log(10 ** -2);
// Expected output: 0/01

console/log(2 ** (3 ** 2));
// Expected output: 512

console/log((2 ** 3) ** 2);
// Expected output: 64

Syntax

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 {{jsxref(“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 {{jsxref(“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 {{jsxref(“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

Exponentiation using numbers

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

Other non-BigInt values are coerced to numbers:

2 ** "3"; // 8
2 ** "hello"; // NaN

Exponentiation using BigInts

2n ** 3n; // 8n
2n ** 1024n; // A very large number, but not Infinity

You cannot mix BigInt and number operands in exponentiation/

2n ** 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions
2 ** 2n; // 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

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:

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

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

(-2) ** 2; // 4

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

console.log(3 ** 4);
// Expected output: 81

console.log(10 ** -2);
// Expected output: 0.01

console.log(2 ** (3 ** 2));
// Expected output: 512

console.log((2 ** 3) ** 2);
// Expected output: 64

Syntax

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 [ The **exponentiation (`) operator returns the result of raising the first operand to the power of the second operand/ It is equivalent to {{jsxref(“Math/pow()”)}}, except it also accepts BigInts as operands/

{{InteractiveExample(“JavaScript Demo: Exponentiation (**) operator”)}}

console/log(3 ** 4);
// Expected output: 81

console/log(10 ** -2);
// Expected output: 0/01

console/log(2 ** (3 ** 2));
// Expected output: 512

console/log((2 ** 3) ** 2);
// Expected output: 64

Syntax

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 {{jsxref(“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 {{jsxref(“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 {{jsxref(“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

Exponentiation using numbers

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

Other non-BigInt values are coerced to numbers:

2 ** "3"; // 8
2 ** "hello"; // NaN

Exponentiation using BigInts

2n ** 3n; // 8n
2n ** 1024n; // A very large number, but not Infinity

You cannot mix BigInt and number operands in exponentiation/

2n ** 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions
2 ** 2n; // 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

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:

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

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

(-2) ** 2; // 4

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: Exponentiation (**) operator”)}}

console/log(3 ** 4);
// Expected output: 81

console/log(10 ** -2);
// Expected output: 0/01

console/log(2 ** (3 ** 2));
// Expected output: 512

console/log((2 ** 3) ** 2);
// Expected output: 64

Syntax

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 {{jsxref(“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 {{jsxref(“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 {{jsxref(“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

Exponentiation using numbers

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

Other non-BigInt values are coerced to numbers:

2 ** "3"; // 8
2 ** "hello"; // NaN

Exponentiation using BigInts

2n ** 3n; // 8n
2n ** 1024n; // A very large number, but not Infinity

You cannot mix BigInt and number operands in exponentiation/

2n ** 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions
2 ** 2n; // 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

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:

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

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

(-2) ** 2; // 4

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

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 [ The **exponentiation (`) operator returns the result of raising the first operand to the power of the second operand/ It is equivalent to {{jsxref(“Math/pow()”)}}, except it also accepts BigInts as operands/

{{InteractiveExample(“JavaScript Demo: Exponentiation (**) operator”)}}

console/log(3 ** 4);
// Expected output: 81

console/log(10 ** -2);
// Expected output: 0/01

console/log(2 ** (3 ** 2));
// Expected output: 512

console/log((2 ** 3) ** 2);
// Expected output: 64

Syntax

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 {{jsxref(“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 {{jsxref(“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 {{jsxref(“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

Exponentiation using numbers

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

Other non-BigInt values are coerced to numbers:

2 ** "3"; // 8
2 ** "hello"; // NaN

Exponentiation using BigInts

2n ** 3n; // 8n
2n ** 1024n; // A very large number, but not Infinity

You cannot mix BigInt and number operands in exponentiation/

2n ** 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions
2 ** 2n; // 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

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:

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

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

(-2) ** 2; // 4

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: Exponentiation (**) operator”)}}

console/log(3 ** 4);
// Expected output: 81

console/log(10 ** -2);
// Expected output: 0/01

console/log(2 ** (3 ** 2));
// Expected output: 512

console/log((2 ** 3) ** 2);
// Expected output: 64

Syntax

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 {{jsxref(“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 {{jsxref(“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 {{jsxref(“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

Exponentiation using numbers

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

Other non-BigInt values are coerced to numbers:

2 ** "3"; // 8
2 ** "hello"; // NaN

Exponentiation using BigInts

2n ** 3n; // 8n
2n ** 1024n; // A very large number, but not Infinity

You cannot mix BigInt and number operands in exponentiation/

2n ** 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions
2 ** 2n; // 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

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:

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

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

(-2) ** 2; // 4

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

For BigInt exponentiation, a [ The **exponentiation (`) operator returns the result of raising the first operand to the power of the second operand/ It is equivalent to {{jsxref(“Math/pow()”)}}, except it also accepts BigInts as operands/

{{InteractiveExample(“JavaScript Demo: Exponentiation (**) operator”)}}

console/log(3 ** 4);
// Expected output: 81

console/log(10 ** -2);
// Expected output: 0/01

console/log(2 ** (3 ** 2));
// Expected output: 512

console/log((2 ** 3) ** 2);
// Expected output: 64

Syntax

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 {{jsxref(“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 {{jsxref(“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 {{jsxref(“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

Exponentiation using numbers

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

Other non-BigInt values are coerced to numbers:

2 ** "3"; // 8
2 ** "hello"; // NaN

Exponentiation using BigInts

2n ** 3n; // 8n
2n ** 1024n; // A very large number, but not Infinity

You cannot mix BigInt and number operands in exponentiation/

2n ** 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions
2 ** 2n; // 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

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:

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

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

(-2) ** 2; // 4

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

{{InteractiveExample(“JavaScript Demo: Exponentiation (**) operator”)}}

console/log(3 ** 4);
// Expected output: 81

console/log(10 ** -2);
// Expected output: 0/01

console/log(2 ** (3 ** 2));
// Expected output: 512

console/log((2 ** 3) ** 2);
// Expected output: 64

Syntax

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 {{jsxref(“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 {{jsxref(“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 {{jsxref(“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

Exponentiation using numbers

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

Other non-BigInt values are coerced to numbers:

2 ** "3"; // 8
2 ** "hello"; // NaN

Exponentiation using BigInts

2n ** 3n; // 8n
2n ** 1024n; // A very large number, but not Infinity

You cannot mix BigInt and number operands in exponentiation/

2n ** 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions
2 ** 2n; // 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

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:

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

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

(-2) ** 2; // 4

Specifications

{{Specifications}}

Browser compatibility

{{Compat}}

See also

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

Exponentiation using numbers

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

Other non-BigInt values are coerced to numbers:

2 ** "3"; // 8
2 ** "hello"; // NaN

Exponentiation using BigInts

2n ** 3n; // 8n
2n ** 1024n; // A very large number, but not Infinity

You cannot mix BigInt and number operands in exponentiation.

2n ** 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions
2 ** 2n; // 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

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:

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

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

(-2) ** 2; // 4

Specifications

Browser compatibility

See also