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 (/).
Adição (+)
O operador de adição produz a soma dos operadores numéricos ou a concatenação de strings.
Sintaxe
Operador: x + y
Exemplos
// 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"
Subtração (-)
O operador de subtração subtrai os dois operandos, produzindo sua diferença.
Sintaxe
Operador: x - y
Exemplos
5 - 3 // 2
3 - 5 // -2
"foo" - 3 // NaN
Divisão (/)
O operador de divisão produz o quociente de seus operandos onde o operando da esquerda é o dividendo e o da direita é o divisor.
Sintaxe
Operador: x / y
Exemplos
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
Multiplicação (*)
O operador de multiplicação produz o produto dos operandos.
Sintaxe
Operador: x * y
Exemplos
2 * 2 // 4
-2 * 2 // -4
Infinity * 0 // NaN
Infinity * Infinity // Infinity
"foo" * 2 // NaN
Módulo (%)
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.
Sintaxe
Operador: var1 % var2
Examples
12 % 5 // 2
-1 % 2 // -1
NaN % 2 // NaN
Exponenciação (**)
O operador de exponenciação retorna o resultado do primeiro operando elevado ao segundo operando. É o mesmo que var1
var2
, 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)
.
Sintaxe
Operador: var1 ** var2
Notas
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.
Exemplos
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
.)
Incremento (++)
O operador de incremento incrementa (adiciona um a) seu operando e retorna um valor;
- Se usado na forma posfixa, com o operador depois do operando (por exemplo, x++), então ele retorna o valor antes de incrementá-lo.
- Se usado na forma prefixa, com o operador antes do operando (por exemplo, ++x), então ele retorna o valor depois de incrementá-lo.
Sintaxe
Operador: x++ or ++x
Exemplos
// Posfixo
var x = 3;
y = x++; // y = 3, x = 4
// Prefixo
var a = 2;
b = ++a; // a = 3, b = 3
Decremento (--)
O operador de decremento decrementa (subtrai um de) seu operando e retorna um valor.
- Se usado na forma posfixa (por exemplo, x--), então ele retorna o valor antes de decrementá-lo.
- Se usado na forma prefixa (por exemplo, --x), então ele retorna o valor depois de decrementá-lo.
Sintaxe
Operador: x-- or --x
Exemplos
// Posfixo
var x = 3;
y = x--; // y = 3, x = 2
// Prefixo
var a = 2;
b = --a; // a = 1, b = 1
Negação Unária (-)
O operador de negação unária precede seu operando e o nega.
Sintaxe
Operador: -x
Exemplos
var x = 3;
y = -x; // y = -3, x = 3
Soma Unária (+)
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.
Sintaxe
Operador: +x
Exemplos
+3 // 3
+"3" // 3
+true // 1
+false // 0
+null // 0
Especificações
Especificação | Status | Comentário |
---|---|---|
ECMAScript 1ª Edição. | Padrão | Definição inicial. |
ECMAScript 5.1 (ECMA-262) | Padrão | Definido em várias seções da especificação: Operadores aditivos, Operadores Multiplicativos, Expressões Posfixas, Operadores Unários. |
ECMAScript 2015 (6th Edition, ECMA-262) | Padrão | Definido em várias seções da especificação: Operadores aditivos, Operadores Multiplicativos, Expressões Posfixas, Operadores Unários. |
Compatibilidade com Navegadores
Feature | Chrome | Firefox (Gecko) | Internet Explorer | Opera | Safari |
---|---|---|---|---|---|
Basic support | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |
Feature | Android | Chrome for Android | Firefox Mobile (Gecko) | IE Mobile | Opera Mobile | Safari Mobile |
---|---|---|---|---|---|---|
Basic support | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |