Operadores em Scala

Aviso: Este tutorial é uma continuação da Série de Tutoriais Scala. Se você não leu o Guia para Iniciantes em Scala e o IF ELSE em Scala, então dê uma olhada.

Introdução

Um operador é um símbolo ou uma função que sinaliza uma operação a ser executada com um ou mais operandos. Existem muitos tipos diferentes de operadores, enquanto um operando pode ser pensado como uma variável. Os operadores são a base de todas as linguagens de programação. Os operadores permitem que nós executemos vários tipos de operações em operandos. Os operadores informam ao compilador para executar operações como matemáticas (aritméticas), lógicas, de atribuição, etc., e finalmente produzir o resultado.

Existem diferentes tipos de operadores que são usados em muitas linguagens de programação, assim como em Scala, que são os seguintes:

• Operadores Relacionais
• Operadores Aritméticos
• Operadores de Atribuição
• Operadores Lógicos
• Operadores Bit a Bit

Você aprenderá sobre os operadores acima teoricamente e programaticamente.

Operadores Relacionais

Operadores relacionais são principalmente usados para realizar comparações entre duas ou mais variáveis. Se você leu o tutorial IF ELSE em Scala, então você teria observado que você usou o poder dos operadores relacionais nas condições IF ELSE.

Estes operadores relacionais retornam um valor booleano, ou seja, Verdadeiro ou Falso.

Os seguintes são os símbolos dos operadores relacionais que você usa para aplicá-los nas variáveis (Fonte: Operadores em Scala):

• Igual A(==): Ele verifica se duas variáveis ou operandos dados são iguais ou não. Se forem, então ele retorna verdadeiro, caso contrário, retorna falso.

• Diferente De(!=): É o oposto do operador igual a, ou você pode dizer que é o complemento booleano do operador igual a. Ele verifica se dois operandos dados são iguais ou não. Se não forem, então ele retorna verdadeiro, caso contrário, retorna falso.

• Maior que (>): Ele verifica se o primeiro operando é maior que o segundo operando. Se sim, então retorna verdadeiro, caso contrário, retorna falso.

• Menor que (<): É o oposto do operador de maior que, pois verifica se o primeiro operando é menor que o segundo operando. Se sim, retorna verdadeiro, caso contrário, retorna falso.

• Maior que Igual a (>=): Este operador verifica se o primeiro operando é maior ou igual ao segundo operando. Se sim, retorna verdadeiro; caso contrário, retorna falso.

• Menor que Igual a (<=): O oposto do operador de maior que igual a. Ele verifica se o primeiro operando é menor ou igual ao segundo operando. Se sim, retorna verdadeiro; caso contrário, retorna falso.

Vamos agora entender os operadores relacionais com a ajuda de um código.

Para executar o código acima, tudo o que você precisa fazer é digitar scala relation_op.scala e você deve ver um resultado como mostrado abaixo.

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

Operadores Lógicos

Eles são principalmente usados em declarações condicionais, como uma declaração IF ELSE ou até mesmo em um laço while. Eles amalgamam duas ou mais condições ou também compõem o resultado da condição original considerada. (Fonte: Operadores em Scala)

• Operador Lógico AND: Ele retorna verdadeiro quando ambas as condições são satisfeitas. Caso contrário, retorna falso. Usando “e” age como um proxy para o operador &&.

• Operador Lógico OR: Ele retorna verdadeiro quando uma (ou ambas) das condições são satisfeitas. Caso contrário, retorna falso. Usando “ou” age como um proxy para o operador ||.

• NÃO Lógico: Retorna verdadeiro se a condição sendo considerada não for satisfeita. Caso contrário, retorna falso. O uso de “não” atua como uma alternativa para o operador !.

Operadores Aritméticos (Matemáticos)

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

Segue abaixo os operadores aritméticos mais usados no Scala (Fonte: Operadores no Scala):

• Adição: Soma $(+)$ duas variáveis/operandos.

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

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

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

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

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

Vamos escrever uma pequena parte de código e analisar os resultados.

Neste exemplo, você irá usar lists em vez de definir apenas variáveis. Diferentemente de uma variável, uma Lista pode conter um número n de valores com diferentes tipos de dados, eles representam uma lista encadeada em scala e são imutáveis. Você realizará as operações aritméticas em duas listas, em vez de em duas variáveis.

Operadores de Atribuição

Para atribuir um valor a uma variável, operadores de atribuição são usados. Para concluir isso, o operando da direita é considerado como um valor, enquanto o operando da esquerda é normalmente uma variável para a qual o valor é atribuído. O valor pode ter diferentes tipos de dados, como int, float, etc. O tipo de dado das variáveis e do valor devem ser os mesmos, caso contrário, o compilador levanta um erro. (Fonte: Operadores em Scala)

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

• Adição E Atribuição: É usado para adicionar o operando da esquerda com o operando da direita, finalmente atribuindo a ela a variável da esquerda $(+=)$.

• Subtração E Atribuição: Similar à Adição E atribuição. Este é usado para subtrair o operando da esquerda com o operando da direita, finalmente atribuindo a ela a variável da esquerda $(-=) $.

• Multiplicar E Atribuir: É usado para multiplicar o operando esquerdo com o operando direito e depois atribuí-lo à variável no lado esquerdo $(\times =)$.

• Dividir E Atribuir: É usado para dividir o operando esquerdo pelo operando direito e finalmente atribuir o valor à variável no lado esquerdo $(/=)$.

Da mesma forma, existem muitos outros operadores de atribuição. Por fim, vamos escrever um código para entender como eles funcionam programaticamente.

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 seria utilizar as habilidades adquiridas nos três e escrever um programa Scala do zero. Isso não apenas aumentará sua confiança, mas também facilitará sua vida ao seguir tópicos muito mais avançados em Scala.

Referências:

• Operadores em Scala

Sinta-se à vontade para fazer quaisquer perguntas relacionadas a este tutorial na seção de comentários abaixo.