Operadores Aritméticos

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:

The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.

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

El operador de incremento incrementa (agrega uno a) su operando y devuelve un valor.

• Si se usa postfijo, con el operador después del operando (por ejemplo, x++), devuelve el valor antes de incrementar.
• Si se usa prefijo, con el operador antes del operando (por ejemplo, ++x), devuelve el valor después de incrementar.

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.

• Si se usa postfijo (por ejemplo, x--), devuelve el valor antes de decrementar.
• Si usa el prefijo (por ejemplo, --x), entonces devuelve el valor después de decrementar.

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

• Operadores de Asignación