Operadores aritméticos 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 (/).
O operador de adição produz a soma dos operadores numéricos ou a concatenação de strings.
Operador: x + y
// Número + Número -> adição 1 + 2 // 3 // Booleano + Número -> adição true + 1 // 2 // Booleano + Booleano -> adição false + false // 0 // Número + String -> concatenação 5 + "foo" // "5foo" // String + Booleano -> concatenação "foo" + false // "foofalse" // String + String -> concatenação "foo" + "bar" // "foobar"
O operador de subtração subtrai os dois operandos, produzindo sua diferença.
Operador: x - y
5 - 3 // 2 3 - 5 // -2 "foo" - 3 // NaN
O operador de divisão produz o quociente de seus operandos onde o operando da esquerda é o dividendo e o da direita é o divisor.
Operador: x / y
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
O operador de multiplicação produz o produto dos operandos.
Operador: x * y
2 * 2 // 4 -2 * 2 // -4 Infinity * 0 // NaN Infinity * Infinity // Infinity "foo" * 2 // NaN
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. Existe uma proposta de ter um operador real de módulo em uma versão futura do ECMAScript.
Operador: var1 % var2
12 % 5 // 2 -1 % 2 // -1 NaN % 2 // NaN
O operador de exponenciação retorna o resultado do primeiro operando elevado ao segundo operando. É o mesmo que var1var2, onde var1 e var2 são variáveis. O operador de exponenciação é associativo à direita, ou seja, a ** b ** c é igual a a ** (b ** c).
Operador: var1 ** var2
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 (+/-/~/!/delete/void/typeof) imediatamente antes do número base.
-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.
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 inverter o sinal do resultado de uma expressão de exponenciação:
-(2 ** 2) // -4
Para forçar a base de uma expressão de exponenciação para ser um número negativo:
(-2) ** 2 // 4
Nota: JavaScript também tem um operador de lógica binária ^ (XOR). ** e ^ são diferentes (por exemplo : 2 ** 3 === 8 enquanto 2 ^ 3 === 1.)
O operador de incremento incrementa (adiciona um a) seu operando e retorna um valor;
Operador: x++ or ++x
// Posfixo var x = 3; y = x++; // y = 3, x = 4 // Prefixo var a = 2; b = ++a; // a = 3, b = 3
O operador de decremento decrementa (subtrai um de) seu operando e retorna um valor.
Operador: x-- or --x
// Posfixo var x = 3; y = x--; // y = 3, x = 2 // Prefixo var a = 2; b = --a; // a = 1, b = 1
O operador de negação unária precede seu operando e o nega.
Operador: -x
var x = 3; y = -x; // y = -3, x = 3
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 true, false, e null. 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á NaN.
Operador: +x
+3 // 3 +"3" // 3 +true // 1 +false // 0 +null // 0
| Especificação | Status | Comentário |
|---|---|---|
| ECMAScript 1ª Edição. | Padrão | Definição inicial. |
| {{SpecName('ES5.1', '#sec-11.3')}} | {{Spec2('ES5.1')}} | Definido em várias seções da especificação: Operadores aditivos, Operadores Multiplicativos, Expressões Posfixas, Operadores Unários. |
| {{SpecName('ES6', '#sec-postfix-expressions')}} | {{Spec2('ES6')}} | Definido em várias seções da especificação: Operadores aditivos, Operadores Multiplicativos, Expressões Posfixas, Operadores Unários. |
{{CompatibilityTable}}
| Feature | Chrome | Firefox (Gecko) | Internet Explorer | Opera | Safari |
|---|---|---|---|---|---|
| Basic support | {{CompatVersionUnknown}} | {{CompatVersionUnknown}} | {{CompatVersionUnknown}} | {{CompatVersionUnknown}} | {{CompatVersionUnknown}} |
| Feature | Android | Chrome for Android | Firefox Mobile (Gecko) | IE Mobile | Opera Mobile | Safari Mobile |
|---|---|---|---|---|---|---|
| Basic support | {{CompatVersionUnknown}} | {{CompatVersionUnknown}} | {{CompatVersionUnknown}} | {{CompatVersionUnknown}} | {{CompatVersionUnknown}} | {{CompatVersionUnknown}} |