Operadores em Scala

Observação: este tutorial é uma continuação da série de tutoriais de Scala. Se você ainda não leu Beginners Guide to Scala e IF ELSE in Scala, vale a pena conferir.

Introdução

Um operador é um símbolo ou função que indica uma operação a ser executada com um ou mais operandos. Existem vários tipos de operadores, e um operando pode ser pensado como uma variável. Operadores são a base de toda linguagem de programação. Eles permitem realizar diferentes tipos de operações sobre operandos. Os operadores informam ao compilador para executar operações matemáticas (aritméticas), lógicas, de atribuição, entre outras, e por fim produzir o resultado.

Há diferentes tipos de operadores usados em muitas linguagens de programação e também em Scala, entre eles:

• Operadores relacionais
• Operadores aritméticos
• Operadores de atribuição
• Operadores lógicos
• Operadores bit a bit (bitwise)

Você vai aprender sobre esses operadores tanto na teoria quanto na prática.

Operadores relacionais

Operadores relacionais são usados principalmente para comparar duas ou mais variáveis. Se você leu o tutorial IF ELSE in Scala, deve ter percebido que usamos operadores relacionais nas condições do IF ELSE.

Esses operadores relacionais retornam um valor booleano, ou seja, True ou False.

A seguir estão os símbolos dos operadores relacionais que você usa ao aplicá-los às variáveis (Fonte: Operators in Scala):

• Igual a (==): verifica se duas variáveis ou operandos são iguais. Se forem, retorna true; caso contrário, retorna false.

• Diferente de (!=): é o oposto do operador igual a, ou seja, o complemento booleano de igual a. Verifica se dois operandos são diferentes. Se forem, retorna true; caso contrário, retorna false.

• Maior que (>): verifica se o primeiro operando é maior que o segundo. Se for, retorna true; senão, retorna false.

• Menor que (<): é o oposto do operador maior que, pois verifica se o primeiro operando é menor que o segundo. Se for, retorna true; caso contrário, retorna false.

• Maior ou igual a (>=): verifica se o primeiro operando é maior ou igual ao segundo. Se for, retorna true; caso contrário, retorna false.

• Menor ou igual a (<=): oposto de maior ou igual a. Verifica se o primeiro operando é menor ou igual ao segundo. Se for, retorna true; caso contrário, retorna false.

Agora vamos entender os operadores relacionais com a ajuda de um código.

Para executar o código acima, basta digitar scala relation_op.scala e você verá uma saída como a mostrada abaixo.

Em seguida, você vai conhecer os operadores lógicos.

Operadores lógicos

Eles são usados principalmente em estruturas condicionais como IF ELSE ou até em um loop while. Servem para combinar duas ou mais condições ou também para complementar (negar) o resultado da condição considerada. (Fonte: Operators in Scala)

• E lógico (AND): retorna true quando ambas as condições são satisfeitas. Caso contrário, retorna false. Usar “and” age como um atalho para o operador &&.

• OU lógico (OR): retorna true quando uma (ou ambas) das condições é satisfeita. Caso contrário, retorna false. Usar “or” age como um atalho para o operador ||.

• NÃO lógico (NOT): retorna true se a condição considerada não for satisfeita. Caso contrário, retorna false. Usar “not” é uma alternativa ao operador !.

Operadores aritméticos (matemáticos)

Como o nome sugere, operadores aritméticos são usados para executar operações matemáticas entre operandos.

A seguir estão os operadores aritméticos mais usados em Scala (Fonte: Operators in Scala):

• Adição: soma $(+)$ dois valores/operandos.

• Subtração: subtrai $(-)$ dois operandos.

• Multiplicação: multiplica $(\times)$ dois operandos.

• Divisão: divide $(/)$ o primeiro operando pelo segundo.

• Exponenciação: retorna a potência dos operandos. Basicamente, quando um operando é elevado à potência do segundo $(x^y)$ ou $(x**y)$.

• Módulo: quando o primeiro operando é dividido pelo segundo, o restante (ou resto) é o módulo (%).

Vamos escrever rapidamente um pequeno trecho de código e analisar os resultados.

Neste exemplo, você vai usar listas em vez de definir apenas variáveis. Diferente de uma variável, uma List pode armazenar n valores de vários tipos; ela representa uma linked list em Scala e é imutável. Você fará as operações aritméticas sobre duas listas, em vez de dois valores isolados.

Operadores de atribuição

Para atribuir um valor a uma variável, usamos operadores de atribuição. Para isso, o operando da direita é considerado o valor, enquanto o operando da esquerda costuma ser a variável que receberá esse valor. O valor pode ter diferentes tipos de dados, como int, float etc. O tipo de dado da variável e do valor deve ser o mesmo; caso contrário, o compilador gera um erro. (Fonte: Operators in Scala)

• Atribuição simples: operador usado para atribuir um valor à variável $(=)$.

• Adição com atribuição: usado para somar o operando da esquerda com o da direita e, por fim, atribuir o resultado à variável da esquerda $(+=)$.

• Subtração com atribuição: similar à adição com atribuição. Subtrai o operando da direita do operando da esquerda e, então, atribui o resultado à variável da esquerda $(-=)$.

• Multiplicação com atribuição: multiplica o operando da esquerda pelo da direita e atribui o resultado à variável da esquerda $(\times =)$.

• Divisão com atribuição: divide o operando da esquerda pelo da direita e, por fim, atribui o valor à variável da esquerda $(/=)$.

Da mesma forma, existem vários outros operadores de atribuição. Para fechar, vamos escrever um código para entender como funcionam na prática.

Conclusão

Parabéns por concluir este tutorial sobre Scala.

Se você leu os dois tutoriais anteriores, agora já cobriu três tópicos diferentes em Scala. Um exercício útil é juntar as habilidades adquiridas nos três e escrever um programa em Scala do zero. Isso não só vai aumentar sua confiança como também vai facilitar sua vida ao acompanhar temas bem mais avançados em Scala.

Referências:

• Operators in Scala

Fique à vontade para deixar suas dúvidas sobre este tutorial nos comentários abaixo.