Operadores de Scala

Em geral, os operadores são símbolos que realizam operações específicas em valores específicos. Essas dicas são conhecidas como operando. Os operadores incluem aritmética, lógica, atribuição, bitwise, operadores de relação e alguns mais. Como parte deste artigo de Scala, discutiremos os operadores da Scala e obteremos uma compreensão clara dos aspectos da linguagem de programação da Scala com sua sintaxe e códigos de exemplo.

O que são operadores em Scala?

O operador está associado ao código e sintaxe exclusivos que executam para executar uma tarefa. Os operadores são usados ​​entre os operandos. Esses operandos podem ser um ou mais baseados na operação.

Tipos e exemplos de operadores de Scala no Ubuntu 20.04?

Existe uma enorme variedade de operações na linguagem de programação Scala. Discutiremos operadores comuns com seus subtipos junto com os códigos de exemplo.

Exemplo # 1: Usando o operador aritmético em Scala

Como o nome sugere, eles são usados ​​para executar aritmética ou você pode dizer operações matemáticas entre dois valores. A seguir estão os operadores aritméticos amplamente utilizados em Scala.

Adição: O sinal do operador de adição é "+", que adiciona duas variáveis ​​ou operando.

Subtração: Indicado com o sinal “ -”. O operador usado entre os dois valores para subtrair.

Multiplicação: O operador usa o sinal "*" para multiplicar dois operandos ou mais.

Divisão: A divisão do operador é indicada com o sinal "/" divide o primeiro operando pelo segundo.

Expoente: Especifica com o sinal "**" conhecido como o poder. Retorna o valor exponencial do operando.

Vamos executar o exemplo programaticamente. Aqui abaixo, inicializamos as variáveis ​​com valores diferentes e, na declaração de impressão, chamamos todas as operações aritméticas.

Os valores de saída de todas as operações aritméticas são mostradas na imagem abaixo.

Exemplo # 2: Usando o operador relacional em Scala

O operador relacional define a comparação entre o operando, que também é conhecido como operador de comparação. O operador é usado em declarações condicionais e retorna o valor booleano verdadeiro ou falso. A seguir, são subtipos de operadores relacionais.

Igual a (=): O igual ao operador compara os dois operandos, sejam eles iguais ou não e retornam um valor booleano verdadeiro, outros falsos.

Não igual a (!=): O operador é usado para comparação se dois operandos não são iguais a uma condição dada.

Maior que (>): É usado para verificar os maiores valores do operando dado. Se o valor dado tiver que ser maior do que retornos verdadeiros, caso contrário, falsa.

Menor que (<): O operador menos do que é usado para verificar o menor valor do operando dado e retornar true se o operando for menor que o segundo operando.

Menor que igual a (<=): É usado para verificar se um determinado operando deve ser menor que e igual ao segundo operando. No final, teremos condições verdadeiras ou falsas.

Temos um exemplo de código de operadores relacionais abaixo. Como você pode ver, usamos todos os operadores discutidos acima em operadores relacionais. Através da função de impressão, podemos ter os resultados de saída.

Como exibir o valor do resultado da saída usando operadores relacionais.

Exemplo # 3: Usando o operador lógico em scala

O operador lógico é utilizado para associar a saída lógica como valor verdadeiro ou valor falso. Ele também reverte a saída lógica de um operando condicional.

Lógico e (&&): O operador e entre dois operandos retorna um valor verdadeiro se os dois operandos forem valores diferentes de zero, pois 1 else retorna.

Lógico ou (||): Se um dos operandos especificados for diferente de zero no lógico ou operador, teremos verdadeiro valor de retorno.

Lógico não (!): Isso dará o valor oposto do operando dado i.e. Se verdadeiro, então falso vice -versa.

Agora, temos um código de exemplo. Inicializamos um valor booleano em uma variável. A função de impressão retornará a saída da variável após o uso de operadores lógicos.

A saída é mostrada abaixo na tela do terminal.

Exemplo # 4: Usando operador bitwise em scala

O operador bitwise executa o operador de nível de bits individual em operandos, de modo que ele funcione pouco a pouco em cada operando. Abaixo, temos operadores bit newes.

Bitwise e (&): O operador pega dois operandos e executa a operação "e" em todo valor.

Bit nessa ou (|): Ele verifica a operação bit em cada operando em determinado. Se ambos os bits forem zero, ele retornará 0 mais, ele retornará 1 como saída.

Bitwise xor (^): Se ambos os bits forem iguais, ele retornará 0 mais retornará 1. Ele vai verificar o operando bit netwee.

Bit -sweele -não (~): O valor que teremos depois de usar bit -não é um valor de complemento do operando. Muda de 1 para 0 e vice -versa.

Mudança esquerda por bit netwo<<): Neste operador, os operandos mudaram para o lado esquerdo por um número, se o bit fornecido no lado direito do operando

Mudança direita bit -bo (>>): O operador mudou a parte do operando esquerdo para o lado direito por vários bits especificados pelo operando direito

Bitwise, mudança à direita, preenchimento zero (>>>): Ele muda o operando esquerdo para a direita pelo operando direito com um número específico de bits e o zero é preenchido com os valores deslocados.

Vamos ter um código de exemplo do operador bit netwise. Usamos todos os operadores bit -newo mencionados acima.

O valor de saída que obtemos de diferentes operadores de atribuição está na tela abaixo.

Conclusão

No artigo, temos uma discussão profunda sobre os operadores de Scala. Aprendemos quatro grandes operadores que incluem operador aritmético, operador lógico, operador relacional e operador bitwise. Além disso, temos um ótimo entendimento dos subtipos de operadores com seus códigos de exemplo em execução. Este guia ajudará nos scripts Scala.