Los operadores Aritméticos toman valores numéricos (ya sean literales o variables) como sus operandos y retornan un valor numérico único. Los operadores aritméticos estándar son adición o suma (+), sustracción o resta (-), multiplicación (*), y división (/).
Estos operadores trabajan al igual que en la mayoría de otros lenguajes de programacion, excepto el operador /, que retorna una división de punto flotante en JavaScript, no una división truncada como en lenguajes tales como C o Java. Por ejemplo:
{{EmbedInteractiveExample("pages/js/expressions-arithmetic.html")}}
La operación suma se produce mediante la suma de número o strings concatenados.
Operador: x + y
// Número + Número = Adición 1 + 2 // 3 // Bolean + Número = Adición true + 1 // 2 // Bolean + Bolean // Adición false + false // 0 // Número + String = Concatenación 5 + 'foo' // "5foo" // String + Bolean = Concatenación 'foo' + true // "footrue" // String + String = Concatenación 'foo' + 'bar' // "foobar"
La resta se produce cuando se sutraen el resultado de los operadores, produciendo su diferencia.
Operador: x - y
5 - 3 // 2 3 - 5 // -2 'foo' - 3 // NaN
El operador división se produce el cociente de la operación donde el operando izquierdo es el dividendo y el operando derecho es el divisor.
Operador: x / y
1 / 2 // devuelve 0.5 en JavaScript 1 / 2 // devuelve 0 en Java // (Ninguno de los números es explícitamente un número de punto flotante) 1.0 / 2.0 // devuelve 0.5 en JavaScript y Java 2.0 / 0 // devuelve Infinito en JavaScript 2.0 / 0.0 // devuelve Infinito 2.0 / -0.0 // devuelve -Infinito en JavaScript
El operador multiplicación produce el producto de la multiplicación de los operandos.
Operador: x * y
2 * 2 // 4 -2 * 2 // -4 Infinito * 0 // NaN Infinito * Infinito // Infinito 'foo' * 2 // NaN
El operador resto devuelve el resto que queda cuando un operando se divide por un segundo operando. Siempre toma el signo del dividendo, no el divisor. Utiliza una función de modulo incorporada para producir el resultado, que es el resto entero de dividir var1 por var2 - por ejemplo - var1 modulo var2. Existe una propuesta para obtener un operador de módulo real en una versión futura de ECMAScript, con la diferencia de que el resultado del operador de módulo tomaría el signo del divisor, no el dividendo.
Operador: var1 % var2
12 % 5 // 2 -1 % 2 // -1 1 % -2 // 1 NaN % 2 // NaN 1 % 2 // 1 2 % 3 // 2 -4 % 2 // -0 5.5 % 2 // 1.5
El operador de exponenciación devuelve el resultado de elevar el primer operando al segundo operando de potencia. es decir, var1var2, en la declaración anterior, donde var1 y var2 son variables. El operador de exponenciación es asociativo a la derecha. a ** b ** c es igual a a ** (b ** c).
Operador: var1 ** var2
En la mayoría de los lenguajes como PHP y Python y otros que tienen un operador de exponenciación (**), el operador de exponenciación se define para tener una precedencia más alta que los operadores unarios, como unario + y unario -, pero hay algunas excepciones. Por ejemplo, en Bash, el operador ** se define como de menor precedencia que los operadores unarios. En JavaScript, es imposible escribir una expresión de exponenciación ambigua, es decir, no se puede poner un operador unario (+/-/~/!/delete/void/typeof) inmediatamente antes del número de base.
-2 ** 2; // 4 en Bash, -4 en otros idiomas. // Esto no es válido en JavaScript, ya que la operación es ambigua. -(2 ** 2); // -4 en JavaScript y la intención del autor no es ambigua.
2 ** 3 // 8 3 ** 2 // 9 3 ** 2.5 // 15.588457268119896 10 ** -1 // 0.1 NaN ** 2 // NaN 2 ** 3 ** 2 // 512 2 ** (3 ** 2) // 512 (2 ** 3) ** 2 // 64
Para invertir el signo del resultado de una expresión de exponenciación:
-(2 ** 2) // -4
Para forzar la base de una expresión de exponenciación a ser un número negativo:
(-2) ** 2 // 4
Nota: JavaScript también tiene un operador bit a bit ^ (logical XOR). ** y ^ son diferentes (por ejemplo: 2 ** 3 === 8 cuando 2 ^ 3 === 1.)
El operador de incremento incrementa (agrega uno a) su operando y devuelve un valor.
Operador: x++ o ++x
// Postfijo var x = 3; y = x++; // y = 3, x = 4 // Prefijo var a = 2; b = ++a; // a = 3, b = 3
El operador de decremento disminuye (resta uno de) su operando y devuelve un valor.
Operador: x-- o --x
// Postfijo var x = 3; y = x--; // y = 3, x = 2 // Prefijo var a = 2; b = --a; // a = 1, b = 1
El operador de negación unaria precede su operando y lo niega.
Operador: -x
var x = 3; y = -x; // y = -3, x = 3 // el operador de negación unario puede convertir no-números en un número var x = "4"; y = -x; // y = -4
El operador unario más precede su operando y evalúa su operando, pero intenta convertirlo en un número, si no lo está. Aunque la negación unaria (-) también puede convertir no números, unario plus es la manera más rápida y preferida de convertir algo en un número, porque no realiza ninguna otra operación en el número. Puede convertir representaciones de cadenas de enteros y flotantes, así como los valores que no sean cadenas true, false y null. Se admiten enteros en formato decimal y hexadecimal ("0x" -prefijado). Los números negativos son compatibles (aunque no para hexadecimal). Si no puede analizar un valor particular, evaluará a NaN.
Operador: +x
+3 // 3
+'3' // 3
+true // 1
+false // 0
+null // 0
+function(val){ return val } // NaN
| Especificación | Estado | Comentario |
|---|---|---|
| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definición inicial. |
| {{SpecName('ES5.1', '#sec-11.3')}} | {{Spec2('ES5.1')}} |
Definido en varias secciones de la especificación: Operadores aditivos, Operadores multiplicativos, Expresiones Postfijas, Operadores unarios. |
| {{SpecName('ES2015', '#sec-postfix-expressions')}} | {{Spec2('ES2015')}} |
Definido en varias secciones de la especificación: Operadores aditivos, Operadores multiplicativos, Expresiones Postfijas, Operadores unarios. |
| {{SpecName('ES2016', '#sec-postfix-expressions')}} | {{Spec2('ES2016')}} | Operador de exponenciación agregado. |
| {{SpecName('ES2017', '#sec-postfix-expressions')}} | {{Spec2('ES2017')}} | |
| {{SpecName('ESDraft', '#sec-additive-operators')}} | {{Spec2('ESDraft')}} |
{{Compat("javascript.operators.arithmetic")}}