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:

Suma o adición (+)

La operación suma se produce mediante la suma de número o strings concatenados.

Sintaxis

Operador: x + y

Ejemplos:

// 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"

Resta o sustracción (-)

La resta se produce cuando se sutraen el resultado de los operadores, produciendo su diferencia.

Sintaxis

Operador: x - y

Ejemplos

5 - 3     // 2
3 - 5     // -2
'foo' - 3 // NaN

División (/)

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.

Sintaxis

Operador: x / y

Ejemplos

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

Multiplicación (*)

El operador multiplicación produce el producto de la multiplicación de los operandos.

Sintaxis

Operador: x * y

Ejemplos

2 * 2 // 4
-2 * 2 // -4
Infinito * 0 // NaN
Infinito * Infinito // Infinito
'foo' * 2 // NaN

Resto o Residuo  (%)

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.

Sintaxis

Operador: var1 % var2

Ejemplos

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

Exponenciación (**)

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).

Sintaxis

Operador: var1 ** var2

 

Notas

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.

Ejemplos

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.)

 

Incremento (++)

 

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.

Sintaxis

Operador: x++ o ++x

Ejemplos

// Postfijo 
var x = 3;
y = x++; // y = 3, x = 4

// Prefijo
var a = 2;
b = ++a; // a = 3, b = 3

Decremento (--)

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.

Sintaxis

Operador: x-- o --x

Ejemplos

// Postfijo 
var x = 3;
y = x--; // y = 3, x = 2

// Prefijo
var a = 2;
b = --a; // a = 1, b = 1

 

Negación unaria (-)

El operador de negación unaria precede su operando y lo niega.

Sintaxis

Operador: -x

Ejemplos

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

Unario más (+)

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.

Sintaxis

Operador: +x

Ejemplos

+3     // 3
+'3'   // 3
+true  // 1
+false // 0
+null  // 0
+function(val){  return val } // NaN

 

Especificaciones

Especificación Estado Comentario
ECMAScript 1st Edition (ECMA-262) Standard Definición inicial.
ECMAScript 5.1 (ECMA-262) Standard

Definido en varias secciones de la especificación: Operadores aditivos, Operadores multiplicativos, Expresiones Postfijas, Operadores unarios.

ECMAScript 2015 (6th Edition, ECMA-262) Standard

Definido en varias secciones de la especificación: Operadores aditivos, Operadores multiplicativos, Expresiones Postfijas, Operadores unarios.

ECMAScript 2016 (ECMA-262) Standard Operador de exponenciación agregado.
ECMAScript 2017 (ECMA-262) Standard  
ECMAScript Latest Draft (ECMA-262) Draft  

Compatibilidad con navegadores

FeatureChromeEdgeFirefoxInternet ExplorerOperaSafari
Addition (+) Si Si1 Si Si Si
Decrement (--) Si Si1 Si Si Si
Division (/) Si Si1 Si Si Si
Exponentiation (**)521452 No Si ?
Increment (++) Si Si1 Si Si Si
Multiplication (*) Si Si1 Si Si Si
Remainder (%) Si Si1 Si Si Si
Subtraction (-) Si Si1 Si Si Si
Unary negation (-) Si Si1 Si Si Si
Unary plus (+) Si Si1 Si Si Si
FeatureAndroid webviewChrome para AndroidEdge mobileFirefox para AndroidOpera AndroidiOS SafariSamsung Internet
Addition (+) Si Si Si4 Si Si Si
Decrement (--) Si Si Si4 Si Si Si
Division (/) Si Si Si4 Si Si Si
Exponentiation (**)51521452 Si ?6.0
Increment (++) Si Si Si4 Si Si Si
Multiplication (*) Si Si Si4 Si Si Si
Remainder (%) Si Si Si4 Si Si Si
Subtraction (-) Si Si Si4 Si Si Si
Unary negation (-) Si Si Si4 Si Si Si
Unary plus (+) Si Si Si4 Si Si Si

Ver también

 

Etiquetas y colaboradores del documento

Etiquetas: 
Colaboradores en esta página: lajaso, nelruk, enesimo, SphinxKnight, teoli, Mgjbot, Nathymig
Última actualización por: lajaso,