path: root/files/es/web/javascript/referencia/operadores/aritméticos/index.html

---
title: Operadores Aritméticos
slug: Web/JavaScript/Referencia/Operadores/Aritméticos
tags:
  - JavaScript
  - Operador
translation_of: Web/JavaScript/Reference/Operators
translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators
---
<div>{{jsSidebar("Operators")}}</div>

<p>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 (/).</p>

<p>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:</p>

<p>{{EmbedInteractiveExample("pages/js/expressions-arithmetic.html")}}</p>

<h2 id="Suma_o_adición_()"><a name="Addition">Suma o adición (+)</a></h2>

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

<h3 id="Sintaxis">Sintaxis</h3>

<pre class="brush: js"><strong>Operador:</strong> x + y</pre>

<h3 id="Ejemplos">Ejemplos:</h3>

<pre class="brush: js">// 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"
</pre>

<h2 id="Resta_o_sustracción_(-)"><a name="Subtraction">Resta o sustracción (-)</a></h2>

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

<h3 id="Sintaxis_2">Sintaxis</h3>

<pre class="brush: js"><strong>Operador:</strong> x - y</pre>

<h3 id="Ejemplos_2">Ejemplos</h3>

<pre class="brush: js">5 - 3     // 2
3 - 5     // -2
'foo' - 3 // NaN
</pre>

<h2 id="División_()"><a name="Division">División (/)</a></h2>

<p>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.</p>

<h3 id="Sintaxis_3">Sintaxis</h3>

<pre class="brush: js"><strong>Operador:</strong> x / y</pre>

<h3 id="Ejemplos_3">Ejemplos</h3>

<pre class="brush: js">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
</pre>

<h2 id="Multiplicación_(*)"><a name="Multiplication">Multiplicación (*)</a></h2>

<p>El operador multiplicación produce el producto de la multiplicación de los operandos.</p>

<h3 id="Sintaxis_4">Sintaxis</h3>

<pre class="brush: js"><strong>Operador:</strong> x * y</pre>

<h3 id="Ejemplos_4">Ejemplos</h3>

<pre class="brush: js">2 * 2 // 4
-2 * 2 // -4
Infinito * 0 // NaN
Infinito * Infinito // Infinito
'foo' * 2 // NaN</pre>

<h2 id=".25_.28modular.29" name=".25_.28modular.29">Resto o Residuo  (%)</h2>

<p>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 <code>modulo</code> incorporada para producir el resultado, que es el resto entero de dividir <code>var1</code> por <code>var2</code> - por ejemplo - <code>var1</code> modulo <code>var2</code>. <a href="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator">Existe una propuesta para obtener un operador de módulo real en una versión futura de ECMAScript</a>, con la diferencia de que el resultado del operador de módulo tomaría el signo del divisor, no el dividendo.</p>

<h3 id="Sintaxis_5">Sintaxis</h3>

<pre class="brush: js"><strong>Operador:</strong> var1 % var2</pre>

<h3 id="Ejemplos_5">Ejemplos</h3>

<pre class="brush: js">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</pre>

<h2 id="Exponenciación_(**)">Exponenciación (**)</h2>

<p>El operador de exponenciación devuelve el resultado de elevar el primer operando al segundo operando de potencia. es decir, <code>var1<sup>var2</sup></code>, en la declaración anterior, donde <code>var1</code> y <code>var2</code> son variables. El operador de exponenciación es asociativo a la derecha. <code>a ** b ** c</code> es igual a <code>a ** (b ** c)</code>.</p>

<h3 id="Sintaxis_6">Sintaxis</h3>

<pre><strong>Operador:</strong> var1 ** var2</pre>

<p> </p>

<h3 id="Notas">Notas</h3>

<p>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 (<code>+/-/~/!/delete/void/typeof</code>) inmediatamente antes del número de base.</p>

<pre class="brush: js">-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.</pre>

<h3 id="Ejemplos_6">Ejemplos</h3>

<pre class="brush: js">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</pre>

<p>Para invertir el signo del resultado de una expresión de exponenciación:</p>

<pre class="brush: js">-(2 ** 2) // -4</pre>

<p>Para forzar la base de una expresión de exponenciación a ser un número negativo:</p>

<pre class="brush: js">(-2) ** 2 // 4</pre>

<div class="note">
<p><strong>Nota:</strong> JavaScript también tiene <a href="/es/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR">un operador bit a bit ^ (logical XOR)</a>. <code>**</code> y <code>^</code> son diferentes (por ejemplo: <code>2 ** 3 === 8</code> cuando <code>2 ^ 3 === 1</code>.)</p>
</div>

<p> </p>

<h2 id=".2B.2B_.28incremento.29" name=".2B.2B_.28incremento.29">Incremento (++)</h2>

<p> </p>

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

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

<h3 id="Sintaxis_7">Sintaxis</h3>

<pre><strong>Operador:</strong> x++ o ++x</pre>

<h3 id="Ejemplos_7">Ejemplos</h3>

<pre class="brush: js">// Postfijo
var x = 3;
y = x++; // y = 3, x = 4

// Prefijo
var a = 2;
b = ++a; // a = 3, b = 3
</pre>

<h2 id="--_.28decremento.29" name="--_.28decremento.29">Decremento (--)</h2>

<p>El operador de decremento disminuye (resta uno de) su operando y devuelve un valor.</p>

<ul>
 <li>Si se usa postfijo (por ejemplo, x--), devuelve el valor antes de decrementar.</li>
 <li>Si usa el prefijo (por ejemplo, --x), entonces devuelve el valor después de decrementar.</li>
</ul>

<h3 id="Sintaxis_8">Sintaxis</h3>

<pre><strong>Operador:</strong> x-- o --x</pre>

<h3 id="Ejemplos_8">Ejemplos</h3>

<pre class="brush: js">// Postfijo
var x = 3;
y = x--; // y = 3, x = 2

// Prefijo
var a = 2;
b = --a; // a = 1, b = 1</pre>

<p> </p>

<h2 id="-_.28negaci.C3.B3n_unitario.29" name="-_.28negaci.C3.B3n_unitario.29">Negación unaria (-)</h2>

<p>El operador de negación unaria precede su operando y lo niega.</p>

<h3 id="Sintaxis_9">Sintaxis</h3>

<pre><strong>Operador:</strong> -x</pre>

<h3 id="Ejemplos_9">Ejemplos</h3>

<pre class="brush: js">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</pre>

<h2 id="Unario_más_()">Unario más (+)</h2>

<p>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 <code>true</code>, <code>false</code> y <code>null</code>. 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 <a href="/es/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a>.</p>

<h3 id="Sintaxis_10">Sintaxis</h3>

<pre><strong>Operador:</strong> +x</pre>

<h3 id="Ejemplos_10">Ejemplos</h3>

<pre class="brush: js">+3     // 3
+'3'   // 3
+true  // 1
+false // 0
+null  // 0
+function(val){  return val } // NaN</pre>

<p> </p>

<h2 id="Especificaciones">Especificaciones</h2>

<table>
 <tbody>
  <tr>
   <th scope="col">Especificación</th>
   <th scope="col">Estado</th>
   <th scope="col">Comentario</th>
  </tr>
  <tr>
   <td>{{SpecName('ES1')}}</td>
   <td>{{Spec2('ES1')}}</td>
   <td>Definición inicial.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-11.3')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td>
    <p>Definido en varias secciones de la especificación: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Operadores aditivos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.5">Operadores multiplicativos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.3">Expresiones Postfijas</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4">Operadores unarios.</a></p>
   </td>
  </tr>
  <tr>
   <td>{{SpecName('ES2015', '#sec-postfix-expressions')}}</td>
   <td>{{Spec2('ES2015')}}</td>
   <td>
    <p>Definido en varias secciones de la especificación: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-additive-operators">Operadores aditivos</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-multiplicative-operators">Operadores multiplicativos</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-postfix-expressions">Expresiones Postfijas</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-unary-operators">Operadores unarios.</a></p>
   </td>
  </tr>
  <tr>
   <td>{{SpecName('ES2016', '#sec-postfix-expressions')}}</td>
   <td>{{Spec2('ES2016')}}</td>
   <td><a href="https://github.com/rwaldron/exponentiation-operator">Operador de exponenciación</a> agregado.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES2017', '#sec-postfix-expressions')}}</td>
   <td>{{Spec2('ES2017')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-additive-operators')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td> </td>
  </tr>
 </tbody>
</table>

<h2 id="Compatibilidad_con_navegadores">Compatibilidad con navegadores</h2>

<p>{{Compat("javascript.operators.arithmetic")}}</p>

<h2 id="Ver_también">Ver también</h2>

<ul>
 <li><a href="/es/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operadores de Asignación</a></li>
</ul>

<p> </p>