Arithmetic operators

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

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.

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.

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

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

• Operatores de atribuição