Operadores JavaScript

Introdução

Um operador recebe um ou mais valores (seus operandos) e produz um novo valor. Em JavaScript, você usa operadores para fazer aritmética, comparar valores, atribuir valores a variáveis e construir condições lógicas. Este capítulo aborda os operadores que você usa todos os dias — atribuição, aritméticos, comparação e concatenação de string — explica a coerção de tipos que torna alguns resultados surpreendentes e termina com uma referência de precedência de operadores para que você saiba o que é avaliado primeiro.

Alguns termos usados ao longo do texto:

• Operando — o valor sobre o qual um operador age. Em 5 + 3, 5 e 3 são operandos.
• Operador unário — recebe um operando (ex.: -x).
• Operador binário — recebe dois operandos (ex.: x + y).
• Operador ternário — recebe três operandos; JavaScript tem exatamente um (?:).

Operadores de Atribuição

O operador de atribuição básico = armazena um valor em uma variável. Os operadores de atribuição compostos combinam uma operação aritmética com a atribuição, portanto x += 5 é uma abreviação de x = x + 5.

Operador	Exemplo	Equivalente a
=	x = 5	—
+=	x += 5	x = x + 5
-=	x -= 5	x = x - 5
*=	x *= 5	x = x * 5
/=	x /= 5	x = x / 5
%=	x %= 5	x = x % 5
**=	x **= 2	x = x ** 2

---

Observe que = é uma atribuição, não uma comparação. Para comparar valores, use === ou == (veja abaixo).

Operadores Aritméticos em JavaScript

Operadores Básicos: Adição (+), Subtração (-), Multiplicação (*) e Divisão (/)

Esses operadores realizam as quatro operações aritméticas básicas.

---

Módulo (%) e Exponenciação (**)

O módulo (%) retorna o resto de uma divisão — útil para testes como "este número é par?" (n % 2 === 0). A exponenciação (**) eleva um número a uma potência.

---

Mais e Menos Unários

- nega um valor, e o + unário converte seu operando em número — uma forma rápida de transformar uma string numérica em número.

---

Incremento (++) e Decremento (--)

++ adiciona 1 a uma variável e -- subtrai 1. A posição importa: a forma prefixada (++x) altera o valor e retorna o novo, enquanto a forma pós-fixada (x++) retorna o valor antigo primeiro e depois o altera.

---

Operadores de Comparação em JavaScript

Os operadores de comparação sempre retornam um boolean (true ou false). Veja o capítulo dedicado Operadores de Comparação para mais detalhes.

Igualdade Estrita (===) e Frouxa (==)

A igualdade estrita (===) retorna true somente quando ambos os operandos têm o mesmo tipo e o mesmo valor — ela nunca converte tipos. A igualdade frouxa (==) primeiro coerce os operandos a um tipo comum e depois compara, o que pode gerar resultados surpreendentes.

Suas formas negadas são !== (desigualdade estrita) e != (desigualdade frouxa).

---

Maior Que (>), Menor Que (<) e Suas Formas "ou Igual"

Esses operadores comparam a ordenação. Eles também possuem as variantes >= (maior ou igual) e <= (menor ou igual).

---

Comparando Valores Não Numéricos

Com os operadores relacionais (<, >, <=, >=), JavaScript realiza coerção de tipos. A regra: se ambos os operandos forem strings, são comparados caractere por caractere (alfabeticamente); caso contrário, ambos os operandos são convertidos em números antes da comparação.

Isso explica um resultado que parece errado à primeira vista:

---

Comparações com NaN

NaN (Not-A-Number) é o único valor que não é igual a nada, nem a si mesmo. Portanto, === NaN nunca pode ser usado para detectá-lo. Use Number.isNaN() em vez disso.

---

Concatenação de String e o Operador + Binário

Concatenando Strings

Em JavaScript, o operador + é usado tanto para adição numérica quanto para concatenação de string.

---

+ Binário e Coerção de Tipos

Quando um operando é uma string, JavaScript converte o outro para string também.

---

Boas Práticas para Concatenação

---

Operadores Lógicos, Condicionais e de Tipo

JavaScript possui diversas outras famílias de operadores, cada uma com seu próprio capítulo. Aqui está um mapa rápido para que você saiba o que fazem e onde ler mais.

Operadores Lógicos (&&, ||, !)

&& (E), || (OU) e ! (NÃO) combinam condições boolean. && e || também realizam curto-circuito e retornam um de seus operandos (nem sempre um boolean), o que os torna úteis para valores padrão e guardas. Veja Operadores Lógicos.

---

Operador Condicional (Ternário) (?:)

O operador ternário é um if/else compacto que retorna um valor: condição ? valorSeVerdadeiro : valorSeFalso. Veja Operadores Condicionais.

---

typeof e instanceof

typeof retorna uma string com o nome do tipo de um valor. instanceof testa se um object foi criado por um construtor específico — abordado em Verificação de Classe: instanceof.

---

Precedência de Operadores

Quando uma expressão mistura operadores, a precedência decide qual é executado primeiro, e a associatividade decide a ordem entre operadores de igual precedência. Por exemplo, * tem precedência maior que +, então 2 + 3 * 4 é 14, não 20.

Aqui estão os operadores mais comuns, do de maior para o de menor precedência:

Precedência	Operadores	Descrição
Maior	()	Agrupamento
	++ -- (pós-fixo)	Incremento/decremento pós-fixo
	! + - ++ -- typeof (prefixo)	Operadores unários
	**	Exponenciação (associativa à direita)
	* / %	Multiplicar, dividir, resto
	+ -	Adicionar, subtrair
	< <= > >= instanceof	Comparação relacional
	== != === !==	Igualdade
	&&	E lógico
	||	OU lógico
	? :	Condicional (ternário)
Menor	= += -= …	Atribuição (associativa à direita)

---

Resumo e Armadilhas Comuns

• Use === / !==, não == / != a menos que você queira especificamente a coerção de tipos.
• '2' < true é false porque os operadores relacionais convertem operandos não-string em números (2 < 1).
• Comparar strings é alfabético, portanto '10' < '9' é true mesmo que 10 < 9 seja false.
• Teste NaN com Number.isNaN(x) — x === NaN é sempre false.
• + é sobrecarregado: com um operando string ele concatena ('3' + 2 é '32'); prefira template literals para maior clareza.
• x++ retorna o valor antigo, ++x o novo.
• ** e = são associativos à direita; a maioria dos outros operadores binários é associativa à esquerda.
• Use parênteses em vez de memorizar a tabela de precedência completa.

Prática