Operadores em Scala

Nota: Este tutorial é uma continuação da Série de Tutoriais de Scala. Se você ainda não leu Guia para Iniciantes em Scala e IF ELSE em Scala, confira-os.

Introdução

Um operador é um símbolo ou função que representa uma operação a ser realizada com um ou mais operandos. Existem muitos tipos diferentes de operadores, enquanto um operando pode ser considerado como uma variável. Operadores são a base de todas as linguagens de programação. Eles nos permitem realizar vários tipos de operações em operandos. Os operadores informam ao compilador para executar operações como matemática (aritmética), lógica, atribuição, etc. e finalmente exibir o resultado.

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

• Operador Relacional
• Operador Aritmético
• Operador de Atribuição
• Operador Lógico
• Operador Bit a Bit

Você aprenderá sobre os operadores acima tanto teoricamente quanto programaticamente.

Operadores Relacionais

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

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

A seguir estã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 as duas variáveis ou operandos fornecidos são iguais ou não. Se sim, então retorna verdadeiro, caso contrário, retorna falso.

• Diferente de(!=): É o oposto do operador igual a, ou seja, um complemento booleano do operador igual a. Ele verifica se os dois operandos fornecidos são iguais ou não. Se não forem, então retorna verdadeiro, caso contrário, retorna falso.

• Maior Que(>): Verifica se o primeiro operando é maior que o segundo operando. Se for, retorna verdadeiro; caso contrário, retorna falso.

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

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

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

Agora vamos 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ê deverá ver uma saída como a mostrada abaixo.

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

Operadores Lógicos

Eles são usados principalmente em instruções condicionais como uma IF ELSE ou até mesmo em um while. Ele combina duas ou mais condições ou também complementa a saída da condição original, que é considerada. (Fonte: Operadores em Scala)

• AND Lógico: Retorna verdadeiro quando ambas as condições são atendidas. Caso contrário, retorna falso. Usar “and” atua como um proxy para o operador &&.

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

• Lógico NÃO: Retorna verdadeiro se a condição em consideração não for satisfeita. Caso contrário, retorna falso. Usar “não” age como uma alternativa para o operador !.

Operadores Aritméticos (Matemáticos)

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

Seguem 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 potência exponencial 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 um pequeno pedaço de código e analisar os resultados.

Neste exemplo, você irá usar lists em vez de definir apenas variáveis. Diferente de uma variável, uma Lista pode conter n número de valores com vários tipos de dados, eles representam listas encadeadas em scala e são imutáveis. Você executará 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 de ambas as variáveis e o valor devem ser o mesmo, 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: Ele é usado para adicionar o operando da esquerda com o operando da direita e, finalmente, atribuí-lo à variável do lado esquerdo $(+=)$.

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

• Multiplicação e Atribuição: É usado para multiplicar o operando esquerdo pelo operando direito e, em seguida, atribuí-lo à variável da esquerda $(\times =)$.

• Divisão e Atribuição: É usado para dividir o operando esquerdo pelo operando direito e, finalmente, atribuir o valor à variável da esquerda $(/=)$.

Como você pode ver, existem muitos outros operadores de atribuição. Vamos finalmente escrever um código para entender como eles funcionam programaticamente.

Conclusão

Parabéns por completar este tutorial sobre Scala.

Se você ler os dois tutoriais anteriores, você agora cover três tópicos diferentes em Scala. Um exercício útil seria combinar as habilidades adquiridas de todos três e escrever um programa Scala de raiz. Isto não só aumentará sua confiança, mas também fazerá com que sua vida seja mais fácil seguindo tópicos muito avançados em Scala.

Referências:

• Operadores em Scala

Por favor, não hesite em fazer questões relacionadas a este tutorial nos comentários abaixo.