O melhor tutorial operador Scala em 2024. Neste tutorial você pode aprender operadores aritméticos,Operadores relacionais,Operadores lógicos,Operadores bit a bit,Operadores de atribuição,Precedência de operador,
Um operador é um símbolo, usado para dizer ao compilador para executar um Determinado operações matemáticas e lógicas.
Scala ricos embutidos operadores, incluindo os seguintes tipos:
operadores aritméticos
Operadores relacionais
Operadores lógicos
Operadores bit a bit
Operadores de atribuição
Em seguida, vamos explicar-lhe mais do que a aplicação de vários operadores.
A tabela a seguir lista os operadores de suporte aritméticas Scala.
Uma variável assumida como 10, B 20:
operadores | descrição | Exemplos |
---|---|---|
+ | mais | Um resultado da operação + B é de 30 |
- | menos | A - o resultado da operação B é de -10 |
* | sinal de multiplicação | Um resultado da operação * B é de 200 |
/ | Sinal de divisão | B / A resultado da operação é de 2 |
% | restante | B% o resultado do cálculo é 0 |
object Test { def main(args: Array[String]) { var a = 10; var b = 20; var c = 25; var d = 25; println("a + b = " + (a + b) ); println("a - b = " + (a - b) ); println("a * b = " + (a * b) ); println("b / a = " + (b / a) ); println("b % a = " + (b % a) ); println("c % a = " + (c % a) ); } }
Implementação do código acima, a saída é:
$ scalac Test.scala $ scala Test a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5
A tabela a seguir lista o Scala apoiar os operadores relacionais.
Uma variável assumida como 10, B 20:
operadores | descrição | Exemplos |
---|---|---|
== | igual | (A == B) o resultado da operação é falso |
! = | não é igual | (A! = B) o resultado da operação é verdade |
> | maior do que | (A> B) o resultado da operação é falso |
< | menos que | (A <B) o resultado da operação é verdade |
> = | Maior do que ou igual | (A> = B) o resultado da operação é falso |
<= | Menor ou igual | (A <= B) o resultado da operação é verdade |
object Test { def main(args: Array[String]) { var a = 10; var b = 20; println("a == b = " + (a == b) ); println("a != b = " + (a != b) ); println("a > b = " + (a > b) ); println("a < b = " + (a < b) ); println("b >= a = " + (b >= a) ); println("b <= a = " + (b <= a) ); } }
Implementação do código acima, a saída é:
$ scalac Test.scala $ scala Test a == b = false a != b = true a > b = false a < b = true b >= a = true b <= a = false
A tabela a seguir lista o Scala suporta operadores lógicos.
Uma variável assumida como 1, B é 0:
operadores | descrição | Exemplos |
---|---|---|
&& | lógica e | (A && B) o resultado da operação é falso |
|| | lógico ou | (A || B) o resultado da operação é verdade |
! | NÃO lógico | ! (A && B) o resultado da operação é verdade |
object Test { def main(args: Array[String]) { var a = true; var b = false; println("a && b = " + (a&&b) ); println("a || b = " + (a||b) ); println("!(a && b) = " + !(a && b) ); } }
Implementação do código acima, a saída é:
$ scalac Test.scala $ scala Test a && b = false a || b = true !(a && b) = true
Operadores bit a bit bits usados para operar, ~, &, |, ^ foram negados, eo bit, ou por pouco e, bit a bit operação XOR com os seguintes exemplos de mesa:
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
Se A = 60; e B = 13; duas variáveis correspondente ao binário é:
A = 0011 1100 B = 0000 1101 -------位运算---------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
A regra Scala bit a bit como segue:
operadores | descrição | Exemplos |
---|---|---|
& | Bit a bit operador AND | (A & b) saída de 12, explicação binária: 0000 1100 |
| | OR bit a bit operador | (A | b) a saída 61, explicação binária: 00111101 |
^ | Bit a bit OU exclusivo do operador | (A ^ b) a saída de 49, explicação binária: 00110001 |
~ | Operadores bit a bit | (~ A) -61 de saída, explicação binária: 1100 0011 em uma forma simbólica complementar número binário. |
<< | operador móvel esquerda | um << 2 saídas de 240 interpretação binário: 11110000 |
>> | Os operadores móveis para a direita | um >> 2 de saída 15, explicação binária: 0000 1111 |
>>> | deslocamento para a direita sem sinal | A >>> 2 saídas de 15 explicação binária: 0000 1111 |
object Test { def main(args: Array[String]) { var a = 60; /* 60 = 0011 1100 */ var b = 13; /* 13 = 0000 1101 */ var c = 0; c = a & b; /* 12 = 0000 1100 */ println("a & b = " + c ); c = a | b; /* 61 = 0011 1101 */ println("a | b = " + c ); c = a ^ b; /* 49 = 0011 0001 */ println("a ^ b = " + c ); c = ~a; /* -61 = 1100 0011 */ println("~a = " + c ); c = a << 2; /* 240 = 1111 0000 */ println("a << 2 = " + c ); c = a >> 2; /* 215 = 1111 */ println("a >> 2 = " + c ); c = a >>> 2; /* 215 = 0000 1111 */ println("a >>> 2 = " + c ); } }
Implementação do código acima, a saída é:
$ scalac Test.scala $ scala Test a & b = 12 a | b = 61 a ^ b = 49 ~a = -61 a << 2 = 240 a >> 2 = 15 a >>> 2 = 15
As listas a seguir o operador Scala linguagem atribuição de apoio:
operadores | descrição | Exemplos |
---|---|---|
= | Simples operador de atribuição, especifica o operando direito atribuído ao operando esquerdo. | C resultado = A + B + A operação B é atribuído a C |
+ = | Adicionando após a atribuição, os lados esquerdo e direito do operando antes de adicionar atribuído ao operando esquerdo. | C + = A corresponde a C = C + A |
- = | Depois de atribuição de subtração, os operandos esquerdo e direito de ambos os lados do operando esquerdo após subtracção atribuído. | C - = A corresponde a C = C - A |
* = | Em seguida, multiplicando-se a atribuição, os lados esquerdo e direito dos operandos são multiplicados antes atribuição para o operando esquerdo. | C * = A corresponde a C = C * A |
/ = | Dividido após a atribuição, os lados esquerdo e direito do operando divisória após atribuição para o operando esquerdo. | C / = A é equivalente C = C / A |
% = | Remanescente após a atribuição, os lados esquerdo e direito do operando resto depois de atribuição para o operando esquerdo. | C% = A é equivalente a C = C% A |
<< = | Bit a bit à esquerda após a atribuição | C << = 2 corresponde a C = C << 2 |
>> = | Bit a bit logo após a atribuição | C >> = 2 é equivalente a C = C >> 2 |
& = | Bit a bit e atribuição após operação | C & = 2 é equivalente a C = C & 2 |
= ^ | Bit a bit OU exclusivo do operador e, em seguida, atribuído | C ^ = 2 é equivalente a C = C ^ 2 |
| = | OR bit a bit atribuição após | C | = 2 corresponde a C = C | 2 |
object Test { def main(args: Array[String]) { var a = 10; var b = 20; var c = 0; c = a + b; println("c = a + b = " + c ); c += a ; println("c += a = " + c ); c -= a ; println("c -= a = " + c ); c *= a ; println("c *= a = " + c ); a = 10; c = 15; c /= a ; println("c /= a = " + c ); a = 10; c = 15; c %= a ; println("c %= a = " + c ); c <<= 2 ; println("c <<= 2 = " + c ); c >>= 2 ; println("c >>= 2 = " + c ); c >>= 2 ; println("c >>= a = " + c ); c &= a ; println("c &= 2 = " + c ); c ^= a ; println("c ^= a = " + c ); c |= a ; println("c |= a = " + c ); } }
Implementação do código acima, a saída é:
$ scalac Test.scala $ scala Test c = a + b = 30 c += a = 40 c -= a = 30 c *= a = 300 c /= a = 1 c %= a = 5 c <<= 2 = 20 c >>= 2 = 5 c >>= a = 1 c &= 2 = 0 c ^= a = 10 c |= a = 10
Em uma expressão pode conter uma pluralidade de diferentes operadores de ligação com diferentes tipos de dados de objectos de dados, uma vez que a expressão tem uma variedade de operações, uma ordem diferente de operações podem ter diferentes resultados, mesmo errada erro de operação, porque quando quando uma expressão contendo uma variedade de operações, de acordo com uma certa ordem devem ser combinadas de modo a assegurar a racionalidade e exactidão dos resultados, a singularidade da operação.
Prioridade por ordem decrescente de cima para baixo, a parte superior tem a maior prioridade, o operador vírgula tem a prioridade mais baixa.
O mesmo nível de prioridade, de acordo com a ordem de ligação de cálculo. A maioria das operações são calculados a partir da esquerda para a direita, apenas três prioridades são da direita para a esquerda combinação, eles são operadores unários, operadores condicionais, operadores de atribuição.
As prioridades básicas precisa se lembrar:
Tipo de operador | operadores | direcção de encadernação |
---|---|---|
avaliação de expressão | () []. Expr ++ expr-- | Esquerda para a direita |
operador unário | * & + - ~ ++ Expr --expr * /% + - >> << <> <=> = ==! = | Direita para a esquerda |
Operadores bit a bit | & ^ | && || | Esquerda para a direita |
operador ternário | ?: | Direita para a esquerda |
Operadores de atribuição | = + = - = * = / =% = >> = << = & = ^ = | = | Direita para a esquerda |
vírgula | , | Esquerda para a direita |