El mejor tutorial de operador de Scala en 2024. En este tutorial podrás aprender Los operadores aritméticos,Los operadores relacionales,Los operadores lógicos,Los operadores bit a bit,Operadores de asignación,Prioridad de los operadores,
Un operador es un símbolo, que sirve para indicar al compilador para realizar una especificados operaciones matemáticas y lógicas.
Scala ricos incorporados en los operadores, entre ellos los siguientes tipos:
Los operadores aritméticos
Los operadores relacionales
Los operadores lógicos
Los operadores bit a bit
Operadores de asignación
A continuación, vamos a explicar a usted más que la aplicación de diversos operadores.
En la siguiente tabla se muestran los operadores aritméticos apoyo Scala.
Una variable asume como 10, B 20:
operadores | descripción | Ejemplos |
---|---|---|
+ | más | Un resultado de la operación + B es 30 |
- | menos | A - B es resultado de la operación -10 |
* | signo de multiplicación | A B resultado de la operación es de 200 * |
/ | Signo de división | B / A resultado de la operación es de 2 |
% | resto | B% Un resultado del cálculo es 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) ); } }
Aplicación del código anterior, la salida es:
$ scalac Test.scala $ scala Test a + b = 30 a - b = -10 a * b = 200 b / a = 2 b % a = 0 c % a = 5
La siguiente tabla muestra la Scala apoyar a los operadores relacionales.
Una variable asume como 10, B 20:
operadores | descripción | Ejemplos |
---|---|---|
== | igual | (A == B) resultado de la operación es falsa |
! = | no es igual | (A! = B) resultado de la operación es cierto |
> | más que | (A> B) resultado de la operación es falsa |
< | menos que | (A <B) resultado de la operación es cierto |
> = | Mayor o igual | (A> = B) el resultado de la operación es falsa |
<= | Menor o igual | (A <= B) resultado de la operación es cierto |
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) ); } }
Aplicación del código anterior, la salida es:
$ scalac Test.scala $ scala Test a == b = false a != b = true a > b = false a < b = true b >= a = true b <= a = false
La siguiente tabla muestra la Scala es compatible con los operadores lógicos.
Una variable asumida como 1, B es 0:
operadores | descripción | Ejemplos |
---|---|---|
&& | La lógica y la | (A && B) resultado de la operación es falsa |
|| | lógico o | (A || B) resultado de la operación es cierto |
! | NO lógico | ! (A && B) resultado de la operación es cierto |
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) ); } }
Aplicación del código anterior, la salida es:
$ scalac Test.scala $ scala Test a && b = false a || b = true !(a && b) = true
bits de operadores de bits usados para operar, ~, &, |, ^ fueron negado, y el bit, o por bit y, bit a bit operación XOR con los siguientes ejemplos de la tabla:
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 |
Si A = 60 y B = 13; dos variables correspondientes a binario es:
A = 0011 1100 B = 0000 1101 -------位运算---------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011
La regla Scala bit a bit de la siguiente manera:
operadores | descripción | Ejemplos |
---|---|---|
y | Operador AND | (A y B) de salida 12, la explicación binaria: 0000 1100 |
| | Operador binario OR | (A | b) la salida 61, la explicación binaria: 00111101 |
^ | Bit a bit OR exclusiva del operador | (A ^ b) la salida 49, la explicación binaria: 00110001 |
~ | Los operadores bit a bit | (~ A) -61 de salida, la explicación binaria: 1100 0011 en una forma simbólica complementar número binario. |
<< | El operador móvil izquierda | un << 2 salidas 240 interpretación binaria: 11110000 |
>> | Los operadores móviles a la derecha | un >> 2 de salida 15, la explicación binaria: 0000 1111 |
>>> | desplazamiento sin signo de la derecha | A >>> 2 salidas 15 de explicación binaria: 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 ); } }
Aplicación del código anterior, la salida es:
$ 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
Las siguientes listas de operador Scala lenguaje de asignación de apoyo:
operadores | descripción | Ejemplos |
---|---|---|
= | operador de asignación simple, especifica el operando derecho asignado a la izquierda del operando. | C resultado = A + B A + B operación se asigna a C |
+ = | Añadiendo después de la asignación, los lados izquierdo y derecho del operando antes de añadir asignan a la izquierda del operando. | C + = A corresponde a C = C + A |
- = | Después de asignación de resta, los operandos izquierdo y derecho en ambos lados del operando de la izquierda después de la sustracción asignados. | C - = A corresponde a C = C - A |
* = | Entonces multiplicar la asignación, los lados izquierdo y derecho de los operandos se multiplican antes de la asignación al operando izquierdo. | C * = A corresponde a C = C * A |
/ = | Dividido después de la asignación, los lados izquierdo y derecho del operando divisoria después de la asignación al operando de la izquierda. | C / = A es equivalente C = C / A |
% = | El resto después de la asignación, los lados izquierdo y derecho del operando resto después de la asignación al operando de la izquierda. | C% = A es equivalente a C = C% A |
<< = | Izquierda en modo bit después de la asignación | C << = 2 corresponde a C = C << 2 |
>> = | Derecha en modo bit después de la asignación | C >> = 2 es equivalente a C = C >> 2 |
y = | Y a nivel de bits de asignación después de la operación | C & = 2 es equivalente a C = C & 2 |
^ = | Bit a bit OR exclusiva del operador y luego asignado | C ^ = 2 es equivalente a C = C ^ 2 |
| = | OR bit a bit después de la asignación | 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 ); } }
Aplicación del código anterior, la salida es:
$ 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
En una expresión puede contener una pluralidad de diferentes operadores de conexión con diferentes tipos de datos de objetos de datos; ya que la expresión tiene una variedad de operaciones, un orden diferente de las operaciones puede tener diferentes resultados incluso error funcionamiento erróneo, ya que cuando cuando una expresión que contiene una variedad de operaciones, de acuerdo con un cierto orden debe combinarse con el fin de garantizar la racionalidad y exactitud de los resultados, la singularidad de la operación.
Prioridad en orden descendente, de arriba abajo, la parte superior tiene la prioridad más alta, el operador coma tiene la prioridad más baja.
El mismo nivel de prioridad, de acuerdo con el orden de enlace de cálculo. La mayoría de las operaciones se calculan de izquierda a derecha, sólo tres prioridades son de derecha a izquierda combinación, son los operadores unarios, operadores condicionales, operadores de asignación.
Las prioridades básicas deben recordar:
Tipo de operador | operadores | dirección de encuadernación |
---|---|---|
evaluación de la expresión | () []. Expr ++ expr-- | De izquierda a derecha |
operador unitario | * Y + - ~ ++ Expr --expr * /% + - >> << <> = <=> ==! = | De derecha a izquierda |
Los operadores bit a bit | y ^ | && || | De izquierda a derecha |
operador ternario | ?: | De derecha a izquierda |
Operadores de asignación | = + = - = * = / =% = >> << = = & = ^ = | = | De derecha a izquierda |
coma | , | De izquierda a derecha |