path: root/files/pt-br/conflicting/web/javascript/reference/operators/index.html

---
title: Arithmetic operators
slug: Web/JavaScript/Reference/Operators/Arithmetic_Operators
tags:
  - JavaScript
  - Operadores
translation_of: Web/JavaScript/Reference/Operators
translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators
---
<div>{{jsSidebar("Operadores")}}</div>

<p><strong>Operadores aritméticos</strong> tem valores numéricos (literais ou variáveis) como seus operadores e retornam um valor numérico único. Os operadores aritméticos padrões são adição (+), subtração (-), multiplicação (*), e divisão (/).</p>

<h2 id="Adição_()"><a name="Addition">Adição (+)</a></h2>

<p>O operador de adição produz a soma dos operadores numéricos ou a concatenação de strings.</p>

<h3 id="Sintaxe">Sintaxe</h3>

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

<h3 id="Exemplos">Exemplos</h3>

<pre class="brush: js">// Número + Número -&gt; adição
1 + 2 // 3

// Booleano + Número -&gt; adição
true + 1 // 2

// Booleano + Booleano -&gt; adição
false + false // 0

// Número + String -&gt; concatenação
5 + "foo" // "5foo"

// String + Booleano -&gt; concatenação
"foo" + false // "foofalse"

// String + String -&gt; concatenação
"foo" + "bar" // "foobar"
</pre>

<h2 id="Subtração_(-)"><a name="Subtraction">Subtração (-)</a></h2>

<p>O operador de subtração subtrai os dois operandos, produzindo sua diferença.</p>

<h3 id="Sintaxe_2">Sintaxe</h3>

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

<h3 id="Exemplos_2">Exemplos</h3>

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

<h2 id="Divisão_()"><a name="Division">Divisão (/)</a></h2>

<p>O operador de divisão produz o quociente de seus operandos onde o operando da esquerda é o dividendo e o da direita é o divisor.</p>

<h3 id="Sintaxe_3">Sintaxe</h3>

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

<h3 id="Exemplos_3">Exemplos</h3>

<pre class="brush: js">1 / 2      // retorna 0.5 em JavaScript
1 / 2      // retorna 0 em Java
// (nenhum dos números é explicitamente um número de ponto flutuante)

1.0 / 2.0  // retorna 0.5 em JavaScript e Java

2.0 / 0    // retorna Infinity em JavaScript
2.0 / 0.0  // retorna Infinity também
2.0 / -0.0 // retorna -Infinity em JavaScript</pre>

<h2 id="Multiplicação_(*)"><a name="Multiplication">Multiplicação (*)</a></h2>

<p>O operador de multiplicação produz o produto dos operandos.</p>

<h3 id="Sintaxe_4">Sintaxe</h3>

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

<h3 id="Exemplos_4">Exemplos</h3>

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

<h2 id="Módulo_()"><a name="Remainder">Módulo (%)</a></h2>

<p>O operador de módulo retorna o primeiro operando módulo o segundo, isto é, var1 módulo var2, na sentença anterior, onde var1 e var 2 são variáveis. A função módulo é o resto inteiro da divisão de var1 por var2. <a href="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator" title="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator">Existe uma proposta de ter um operador real de módulo em uma versão futura do ECMAScript.</a></p>

<h3 id="Sintaxe_5">Sintaxe</h3>

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

<h3 id="Examples">Examples</h3>

<pre class="brush: js">12 % 5 // 2
-1 % 2 // -1
NaN % 2 // NaN
</pre>

<h2 id="Exponenciação_(**)"><a id="Exponenciação" name="Exponenciação">Exponenciação (**)</a></h2>

<p>O operador de exponenciação retorna o resultado do primeiro operando elevado ao segundo operando. É o mesmo que <code>var1</code><sup><code>var2</code></sup>, onde <code>var1</code> e <code>var2</code> são variáveis. O operador de exponenciação é associativo à direita, ou seja, <code>a ** b ** c</code> é igual a <code>a ** (b ** c)</code>.</p>

<h3 id="Sintaxe_6">Sintaxe</h3>

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

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

<p>Em várias linguagens como PHP e Python e outras que tem o operador de exponenciação (**), a exponenciação tem prioridade do que operações unárias, como + e  -, mas tem algumas exceções. Por exemplo, no Bash o operador ** é definido por ter menos prioridade do que operadores unários. No JavaScript, é impossível escrever uma expressão de exponenciação ambígua, i.e. você não pode colocar um operador unário (<code>+/-/~/!/delete/void/typeof</code>) imediatamente antes do número base.</p>

<pre>-2 ** 2;
// 4 no Bash, -4 em outras linguagens.
// Isso é inválido no JavaScript, pois a operação é ambígua.


-(2 ** 2);
// -4 no JavaScript e a intenção do autor não é ambígua.
</pre>

<h3 id="Exemplos_5">Exemplos</h3>

<pre>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 inverter o sinal do resultado de uma expressão de exponenciação:</p>

<pre>-(2 ** 2) // -4
</pre>

<p>Para forçar a base de uma expressão de exponenciação para ser um número negativo:</p>

<pre>(-2) ** 2 // 4
</pre>

<div class="note">
<p><strong>Nota:</strong> JavaScript também tem  <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR">um operador de lógica binária ^ (XOR)</a>. <code>**</code> e <code>^</code> são diferentes (por exemplo : <code>2 ** 3 === 8</code> enquanto <code>2 ^ 3 === 1</code>.)</p>
</div>

<h2 id="Incremento_()"><a name="Increment">Incremento (++)</a></h2>

<p>O operador de incremento incrementa (adiciona um a) seu operando e retorna um valor;</p>

<ul>
 <li>Se usado na forma posfixa, com o operador depois do operando (por exemplo, x++), então ele retorna o valor antes de incrementá-lo.</li>
 <li>Se usado na forma prefixa, com o operador antes do operando (por exemplo, ++x), então ele retorna o valor depois de incrementá-lo.</li>
</ul>

<h3 id="Sintaxe_7">Sintaxe</h3>

<pre class="syntaxbox"><strong>Operador:</strong> x++ or ++x
</pre>

<h3 id="Exemplos_6">Exemplos</h3>

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

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

<h2 id="Decremento_(--)"><a name="Decrement">Decremento (--)</a></h2>

<p>O operador de decremento decrementa (subtrai um de) seu operando e retorna um valor.</p>

<ul>
 <li>Se usado na forma posfixa (por exemplo, x--), então ele retorna o valor antes de decrementá-lo.</li>
 <li>Se usado na forma prefixa (por exemplo, --x), então ele retorna o valor depois de decrementá-lo.</li>
</ul>

<h3 id="Sintaxe_8">Sintaxe</h3>

<pre class="syntaxbox"><strong>Operador:</strong> x-- or --x
</pre>

<h3 id="Exemplos_7">Exemplos</h3>

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

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

<h2 id="Negação_Unária_(-)"><a name="Unary_negation">Negação Unária (-)</a></h2>

<p>O operador de negação unária precede seu operando e o nega.</p>

<h3 id="Sintaxe_9">Sintaxe</h3>

<pre class="syntaxbox"><strong>Operador:</strong> -x
</pre>

<h3 id="Exemplos_8">Exemplos</h3>

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

<h2 id="Soma_Unária_()"><a name="Unary_plus">Soma Unária</a> (+)</h2>

<p>O operador de soma unária precede seu operando e calcula para seu operando mas tenta convertê-lo para um número, caso ainda não o seja. Apesar da negação unária (-) também poder converter não-números, a soma unária é a forma mais rápida e a forma preferida de converter alguma coisa em um número, porque ele não realiza nenhuma outra operação no número. Ele pode converter strings que representam inteiros e ponto flutuante, bem como os valores de não-string <code>true</code>, <code>false</code>, e <code>null</code>. Inteiros em formato decimal e hexadecimal ("0x"-prefixado) são suportados. Números negativos são suportados (não os hexadecimais). Caso não possa analisar um determinado valor, o operador retornará <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a>.</p>

<h3 id="Sintaxe_10">Sintaxe</h3>

<pre class="syntaxbox"><strong>Operador:</strong> +x
</pre>

<h3 id="Exemplos_9">Exemplos</h3>

<pre class="brush: js">+3     // 3
+"3"   // 3
+true  // 1
+false // 0
+null  // 0
</pre>

<h2 id="Especificações">Especificações</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Especificação</th>
   <th scope="col">Status</th>
   <th scope="col">Comentário</th>
  </tr>
  <tr>
   <td>ECMAScript 1ª Edição.</td>
   <td>Padrão</td>
   <td>Definição inicial.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-11.3')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td>Definido em várias seções da especificação: <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">Expressões Posfixas</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4">Operadores Unários</a>.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-postfix-expressions')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>Definido em várias seções da especificação: <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">Expressões Posfixas</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4">Operadores Unários</a>.</td>
  </tr>
 </tbody>
</table>

<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>

<p>{{CompatibilityTable}}</p>

<div id="compat-desktop">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Feature</th>
   <th>Chrome</th>
   <th>Firefox (Gecko)</th>
   <th>Internet Explorer</th>
   <th>Opera</th>
   <th>Safari</th>
  </tr>
  <tr>
   <td>Basic support</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
 </tbody>
</table>
</div>

<div id="compat-mobile">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Feature</th>
   <th>Android</th>
   <th>Chrome for Android</th>
   <th>Firefox Mobile (Gecko)</th>
   <th>IE Mobile</th>
   <th>Opera Mobile</th>
   <th>Safari Mobile</th>
  </tr>
  <tr>
   <td>Basic support</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
   <td>{{CompatVersionUnknown}}</td>
  </tr>
 </tbody>
</table>
</div>

<h2 id="Veja_também">Veja também</h2>

<ul>
 <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operatores de atribuição</a></li>
</ul>