Latest web development tutorials

operador de Scala

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.


Los operadores aritméticos

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

Ejemplos

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) );
      
   }
}

Instancia en ejecución »

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

Los operadores relacionales

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

Ejemplos

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

Los operadores lógicos

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

Ejemplos

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

Los operadores bit a bit

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

Ejemplos

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

Operadores de asignación

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

Ejemplos

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

Prioridad de los operadores

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:

  • puntero óptima, unario que los operadores binarios. Como el signo.
  • En primer lugar la multiplicación y la división (módulo) después de la sustracción.
  • Primera operación de desplazamiento aritmético después del último cómputo de bits. Por favor, preste especial atención a: << 1 2 & 3 + 7 es equivalente a (1 << (3 + 2)) y 7
  • operación lógica cálculo final
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