Exponenciacin (**)

Prubalo

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

Sintaxis

x ** y

Descripcin

El operador ** acepta dos tipos de operandos: nmero y BigInt. Primero intenta transformar los operandos a un valor numrico y prueba sus tipos. Realiza una exponenciacin BigInt si el operando se convirti en un BigInt; de lo contrario, realiza la negacin de nmero. Se genera un TypeError si un operando es convertido a BigInt pero el otro se convierte en un nmero.

Tanto para nmeros como para BigInts, 0 elevado a una potencia positiva devuelve 0 y 0 elevado a una potencia de 0 devuelve 1. Para nmeros, 0 elevado a un nmero negativo devuelve Infinity, mientras que -0 elevado a un nmero negativo devuelve -Infinity.

NaN ** 0 (y su equivalente Math.pow(NaN, 0)) es el nico caso en el que NaN no se propaga a travs de operacines matemticas: devuelve 1 a pesar de que el operando sea NAN. Adems, cuando la base es 1 y el exponente no es infinito, (Infinity o NaN) el comportamiento es diferente a IEEE 754, el cual especifica que el resultado debera ser 1, sin embargo JavaScript retorna NAN para preservar la compatibilidad con versiones anteriores con su comportamiento original.

Para exponenciacin con BigInt, un RangeError es generado si el exponente y es negativo. Esto es porque cualquier exponente negativo probablemente dara como resultado un valor entre 0 y 1 (a menos que la base sea 1, -1 o 0), que se redondea a cero y probablemente sea un error del desarrollador.

El operador de exponenciacin es asociativo derecho: a ** b ** c es igual a a ** (b ** c).

En muchos lenguajes como PHP, Python y otros que tienen un operador de exponenciacin (**), el operador de exponenciacin est definido que el operador de exponenciacin tiene una precedencia mayor que los operadores unarios, como el unario + y el unario -, pero existen algunas exepciones. Por ejemplo, en Bash, ** se define que el operador tiene una precedencia menor que los operadores unarios.

En JavaScript es imposible escribir una expresin de exponenciacin ambigua. Es decir, no se puede colocar un operador unario (con precedencia 14, incluyendo +/-/~/!/++/--/delete/void/typeof/await) inmediatamente antes de el nmero base; hacerlo provocar un error de sintaxis.

Por ejemplo, -2 ** 2 es 4 en Bah, pero es -4 en otros lenguajes (como Python). Esto es invlido en JavaScript, ya que la operacin es ambigua. Se tiene que poner entre parntesis cada lado (-(2 ** 2) por ejemplo) para que la intencin no sea ambigua.

Tenga en cuenta que algunos lenguajes de programacin usan el smbolo de intercalacin ^para la exponenciacin, pero JavaScript usa ese smbolo para el operador XOR bit a bit.

Ejemplos

Exponenciacin bsica

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; // Un nmero muy grande, pero no infinito.

2n ** 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions

// Para hacer una exponenciacin con un BigInt y un elemento que no es un BigInt, convierta cualquiera de los dos operandos
2n ** BigInt(2); // 4n
Number(2n) ** 2; // 4

Asociatividad

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

Uso con operadores unarios

Para invertir el signo del resultado de una expresin de exponenciacin:

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

Para forzar que la base de una expresin de exponenciacin sea un nmero negativo:

(-2) ** 2; // 4

Especificaciones

Compatibilidad con navegadores

Vase tambin

• Adicin (+)
• Sustraccin (-)
• Divisin (/)
• Multiplicacin (*)
• Resto (%)
• Incremento (++)
• Decremento (--)
• Negacin unaria (-)
• Unario ms (+)