Para quem estuda códigos, é comum se deparar com novos símbolos ainda desconhecidos. Hoje você vai entender o que são operadores JavaScript, quais seus tipos, além de saber como é o OR em JavaScript, entre outros.
O que são operadores JavaScript?
Operadores em Javascript são símbolos especiais que envolvem um ou mais operandos com a finalidade de produzir um determinado resultado.
Quais os operadores JavaScript?
Os operadores podem ser aritméticos como soma, subtração e divisão; de comparação como a igualdade; operadores sobre cadeias de caracteres como o de concatenação de strings e, por fim, operadores lógicos JavaScript como o ‘and’ e o ‘or’.
Operador de atribuição
O operador de atribuição básico é o sinal de igual (=). Ele atribui um valor a uma variável:
x = 5
Essa operação atribui a x o valor 5.
Existem também os operadores de atribuição composta que serão explicados com exemplos.
Atribuição composta de soma (+=)
x += 10;
O código acima irá verificar o valor de x, somá-lo a 10 e atribuí-lo novamente a x. Por exemplo, se o valor de x for 5, será feita a soma de 5 com 10 e o valor final, 15, será atribuído novamente a variável x.
Atribuição composta de subtração (-=)
x -= 3;
Como na adição composta, a subtração irá considerar o valor da variável x, subtrair dela o segundo operando, 3, e armazená-lo de volta na variável x.
Atribuição composta de multiplicação (*=)
x *= 8;
Você já deve ter entendido como é o funcionamento da composição do operador de atribuição com operadores aritméticos. No código acima, portanto, o valor de x será multiplicado por 8 e atribuído novamente a x.
Atribuição composta de divisão (/=) e resto (%=)
x /= 2;
x %= 3;
Por fim, a atribuição composta de divisão e resto armazenará na variável x o resultado da divisão de x por 2, e o resto da divisão de x por 3, respectivamente.
Esses operadores compostos são uma contração de uma operação aritmética e outra de atribuição. Por exemplo, a instrução:
p += 7;
é equivalente a:
p = p + 7;
Operadores de comparação
Os operadores de comparação envolvem dois operandos e retornam um resultado lógico. O operador de igualdade (==), por exemplo, retorna verdadeiro (true), caso os operandos tenham o valor igual, e retornará falso (false), caso sejam diferentes.
Vamos ver em detalhes quais são os operadores de comparação que podemos usar quando programamos em Javascript:
Igual (==)
O operador de igualdade compara dois operandos e retorna verdadeiro, se eles forem iguais, e falso, se forem diferentes. Veja os exemplos abaixo:
var x = 5;
x == 5; // retornará verdadeiro
x == ‘5’ // também retornará verdadeiro
x == 4 // retornará falso
x == ‘c’ // também retornará falso
Observe que para o Javascript não importa se os operandos recebidos pelo operador de igualdade são do mesmo tipo. No exemplo acima, o Javascript faz a conversão (casting) de um dos operandos e depois faz a comparação.
Diferente (!=)
Esse operador compara os dois operandos e retorna verdadeiro, se eles forem diferentes, e falso, se forem iguais. A lógica é a inversa do operador de igualdade.
‘string1’ != ‘string2’ // retorna verdadeiro
O exemplo acima também serve para mostrar que além de caracteres, os operadores de comparação também podem ser aplicados a strings.
Igualdade estrita (===)
A igualdade estrita, além de considerar o valor dos operandos, leva em conta também seu tipo:
var op = 100;
op === 100; // retorna true
op === ‘100’ // retorna false
op === 3 // também retorna false
Diferença estrita (!==)
Tem funcionamento análogo à diferença (!=), no entanto, considera se o tipo dos operandos é o mesmo, como o operador de igualdade estrita.
Maior (>)
É usado para indicar se o operador da esquerda é maior que o operador da direita:
5 > 4 // retornará verdadeiro
Menor (<)
Retorna verdadeiro se o operador da esquerda for menor que o operador da direita:
6 < 10 // retornará verdadeiro
Maior ou igual (>=)
Seu funcionamento é semelhante ao operador ‘maior’, mas retorna verdadeiro caso o operador da esquerda seja maior ou igual ao operador da direita. Veja:
var x = 6;
var y = 4;
x >= y // retorna verdadeiro
x >= 6 // também retorna verdadeiro
y >= x // retorna falso
Menor ou igual (<=)
Partindo da declaração das variáveis acima, vamos analisar o seguinte trecho de código:
x <= y
Essa instrução retornará falso, já que 6 é maior que 4. Por outro lado, se invertermos os operandos, a instrução abaixo retornará true.
y <= x
Operadores aritméticos
Esses operadores podem ser velhos conhecidos se você já frequentou aulas de matemática elementar. São usados para fazer operações de soma, subtração, multiplicação, divisão, módulo e exponenciação.
Vamos explorar o uso desses operadores por meio de exemplos. Primeiramente, definiremos dois operandos:
var x = 2;
var y = 4;
Vamos somar os dois operandos:
var res = x + y; // o resultado será 6
Agora, a subtração:
var res = y – x; // o resultado será 2
A multiplicação:
var res = x * y; // o valor da operação será 8
E a divisão:
var res = x / y // como 2 dividido por 4 é 0.5, o res receberá esse valor.
Para a exponenciação, a sintaxe é:
y ** x // retornará 16 que é 4 ao quadrado.
E, finalmente, para o operador de módulo (%), vamos usar variáveis diferentes, pois a divisão entre as variáveis que definimos acima não tem resto:
var dividendo = 12;
var divisor = 5;
var resto = dividendo % divisor; // o valor de resto será 2 que é o resto da divisão de 12 por 5.
Operadores bit a bit
Os operadores bit a bit são utilizados para manipular valores para comparações e cálculos, comparando cada bit do primeiro operando com o correspondente do segundo.
Eles não são considerados operadores lógicos, já que os operandos são tratados como uma sequência de 32 bits, representados por zeros e uns, em vez de números decimais, hexadecimais ou octais.
Operadores lógicos
São usados para realizar operações lógicas. Elas podem ser do tipo AND, OR e NOT. Os operandos devem ser lógicos, verdadeiro ou falso. Também podem operar sobre expressões lógicas, ou seja, que retornem valores verdadeiro ou falso.
AND
O operador AND (&&) recebe dois operandos e retorna verdadeiro se, e somente se ambos os operandos sejam verdadeiros. Retorna falso, caso contrário.
Por exemplo, a expressão:
true && true;
retorna true. Já a expressão:
true && false;
retorna false.
OR
Para o operador OR (||) retornar verdadeiro, basta que um dos operandos seja verdadeiro. Ele também retorna verdadeiro caso os dois operandos sejam verdadeiros. Retorna falso, se os dois forem falsos.
A expressão:
true || true;
retorna true bem como a expressão:
true || false;
Já a expressão:
false || false;
retorna false.
NOT
O operador de negação (!) é um operando unário, isto é, opera sobre apenas um operando. Ele nega, inverte o valor lógico do operando. Veja os exemplos:
var x = 2 > 1; // o valor de x é true
!x; // o valor retornado por essa expressão é false
Operadores de string
Concatenação (+)
O operador de concatenação é usado para unir strings em JavaScript. O resultado que ele produz pode ser visto como uma soma.
Este operador irá avaliar os valores dos operandos, que podem ser mais de dois neste caso, e retornar uma string que é a junção desses valores. Vale notar que os operandos não precisam necessariamente ser todos do tipo string.
Retornando aos operadores de comparação do início do artigo, relembremos que, da mesma forma, ao comparar valores de tipos diferentes, o Javascript tenta realizar a transformação (casting) dos valores antes de fazer a comparação, na concatenação, o Javascript faz o casting dos operandos não-string para depois juntar todos na string resultante. Vejamos um exemplo:
var numItens = 10;
var mensagem = ‘O número de itens no pedido é ‘ + numItens + ‘.’;
O valor da variável ‘mensagem’ será: O número de itens no pedido é 10.
Observe que nesse exemplo, há três operandos. A string final é o resultado da concatenação destes três operandos.
Operador condicional (ternário)
Operador ternário JavaScript é uma contração de um operador de atribuição e duas expressões lógicas. A sintaxe é um pouco diferente das que vimos até aqui, mas tem o benefício de evitar escrever um bloco IF para atribuir um valor a uma variável. Vejamos um exemplo:
É preciso calcular o valor final de uma compra. Se o valor da compra for superior a 100, é aplicado um desconto de 10%.
É possível escrever essa lógica da seguinte forma:
var precoCompra = 200;
var desconto = 0.1;
var precoFinal = 0;
if (precoCompra > 100 ) {
precoFinal = precoCompra;
} else {
precoFinal = precoCompra – (precoCompra*desconto);
}
Podemos simplificar este código com o operador ternário:
precoFinal = precoCompra > 100 ? precoCompra – (precoCompra*desconto) : precoCompra
No operador ternário, antes da interrogação (?) deve vir uma expressão lógica. A expressão antes dos dois pontos (:) será o resultado do operador, caso a expressão lógica seja verdadeira. A expressão depois dos dois pontos será o resultado caso ela seja falsa.
Operador vírgula
A vírgula em JavaScript é usada para denotar uma lista de valores. Ela pode ser usada para declarar várias variáveis de uma vez:
var x, y, z;
Para denotar elementos de uma lista:
var lista = [0, 1, 2, 3];
Operadores unários
Operadores unários são aqueles que realizam uma operação sobre apenas um operador. Um exemplo de operador unário é o operador de negação (!) que irá inverter o valor lógico do único operador que precede.
Operadores relacionais
Operador in: é usado para definir se um objeto tem uma determinada propriedade. Ele retorna os valores true ou false. Um uso bastante comum do operador in é para verificar se um elemento pertente a um array:
1 in [1,2,3,4] // retorna true.
Na expressão acima, o JavaScript retornará verdadeiro, pois 1 pertence ao array. Já a expressão abaixo retorna falso, pois o valor 1 não está no array (que é vazio):
1 in [];
instanceof: outro operador relacional, retorna verdadeiro se um objeto é uma instância de outro objeto. Caso contrário, retorna falso.
Precedência de Operadores
As operações que vimos até agora são avaliadas pelo compilador do JavaScript para que elas possam retornar um resultado.
Precedência é a ordem que essa avaliação é feita. Dizer que um operador tem precedência sobre o outro significa dizer que uma operação será avaliada antes da outra.
A ordem precedência dos operadores deve sempre ser considerada para que expressões sejam avaliadas da forma que pretendemos.
Expressões entre parênteses tem precedência mais alta. Em ordem de precedência, multiplicação e divisão são avaliadas antes de somas e subtrações, por exemplo.
Em operações lógicas envolvendo expressões, estas são avaliadas primeiro para depois o operador lógico ser avaliado. Vejamos alguns exemplos:
2 * 3 + 2; // O resultado é 8 pois a multiplicação tem precedência sobre a soma.
2*(3+2); // O resultado é 10 pois a expressão entre parênteses será avaliada antes da multiplicação.
4>6 && 5<2;
Na expressão acima, que retorna false, primeiro serão avaliadas as expressões que envolvem o AND. O resultado será false && false. Logo depois, a expressão resultante (false && false) será avaliada, resultando em false.
Onde aprender mais sobre operadores JavaScript?
Você pode aprender mais sobre a sintaxe desta linguagem aqui no blog da Kenzie e, quando possível, consulte o manual de referência para se aprofundar ainda mais em seus estudos.
Conclusão
Vimos como os operadores são parte importante das ações dentro do seu código. Eles são símbolos que tornam possível diversas operações, tornando-os fundamentais para criar aplicações na web mais lógicas e muito mais completas em recursos.
+1	
ESCRITO POR
Daniel Kriger
Daniel Kriger é co-fundador e CEO da Kenzie Academy Brasil. Entre 2009 e 2013 fundou e gerenciou uma rede de frozen yogurt, alcançando dez lojas e faturamento de + R$ 5MM por ano. Também trabalhou na consultoria estratégica da McKinsey, realizando projetos e coordenando equipes em diferentes indústrias desde Varejo e Construção Civil até Telecom. Na Positivo Tecnologia, desenvolveu projetos internos e coordenou esforços de inovação aberta.