Operadores en Scala

Un operador es un símbolo que representa una operación a realizar con uno o más operandos. Los operadores son la base de cualquier lenguaje de programación. Los operadores nos permiten realizar diferentes tipos de operaciones en los operandos. Hay diferentes tipos de operadores utilizados en Scala de la siguiente manera: 

Operadores aritméticos

Estos se utilizan para realizar operaciones aritméticas/matemáticas en operandos.  

• El operador de suma (+) suma dos operandos. Por ejemplo, x+y .
• El operador de resta (-) resta dos operandos. Por ejemplo, xy .
• El operador de multiplicación (*) multiplica dos operandos. Por ejemplo, x*y .
• El operador de división(/) divide el primer operando por el segundo. Por ejemplo, x/y .
• El operador Módulo (%) devuelve el resto cuando el primer operando se divide por el segundo. Por ejemplo, x%y .
• El operador exponencial (**) devuelve exponencial (potencia) de los operandos. Por ejemplo, x**y .

Ejemplo:  

// Scala program to demonstrate
// the Arithmetic Operators
 
object Arithop
{
 
def main(args: Array[String])
{
    // variables
    var a = 50;
    var b = 30;
     
    // Addition
    println("Addition of a + b = " + (a + b));
     
    // Subtraction
    println("Subtraction of a - b = " + (a - b));
     
    // Multiplication
    println("Multiplication of a * b = " + (a * b));
     
    // Division
    println("Division of a / b = " + (a / b));
     
    // Modulus
    println("Modulus of a % b = " + (a % b));
 
}
}

Producción: 

Addition of a + b = 80
Subtraction of a - b = 20
Multiplication of a * b = 1500
Division of a / b = 1
Modulus of a % b = 20

Operadores relacionales

Los operadores relacionales o los operadores de comparación se utilizan para comparar dos valores. Vamos a verlos uno por uno: 

• El operador Igual a (==) verifica si los dos operandos dados son iguales o no. Si es así, devuelve verdadero. De lo contrario devuelve falso. Por ejemplo, 5==5 devolverá verdadero.
• El operador No es igual a(!=) comprueba si los dos operandos dados son iguales o no. Si no, devuelve verdadero. De lo contrario devuelve falso. Es el complemento booleano exacto del operador ‘==’ . Por ejemplo, 5!=5 devolverá falso.
• El operador Greater Than(>) comprueba si el primer operando es mayor que el segundo operando. Si es así, devuelve verdadero. De lo contrario devuelve falso. Por ejemplo, 6>5 devolverá verdadero.
• El operador menor que (<) verifica si el primer operando es menor que el segundo operando. Si es así, devuelve verdadero. De lo contrario devuelve falso. Por ejemplo, 6<5 devolverá falso.
• El operador Mayor que igual a(>=) comprueba si el primer operando es mayor o igual que el segundo operando. Si es así, devuelve verdadero. De lo contrario devuelve falso. Por ejemplo, 5>=5 devolverá verdadero.
• El operador Less Than Equal To(<=) comprueba si el primer operando es menor o igual que el segundo operando. Si es así, devuelve verdadero. De lo contrario devuelve falso. Por ejemplo, 5<=5 también devolverá verdadero.

Ejemplo:

// Scala program to demonstrate
// the Relational Operators
object Relop
{
 
def main(args: Array[String])
{
    // variables
    var a = 50;
    var b = 30;
     
    // Equal to operator
    println("Equality of a == b is : " + (a == b));
     
    // Not equal to operator
    println("Not Equals of a != b is : " + (a != b));
     
    // Greater than operator
    println("Greater than of a > b is : " + (a > b));
     
    // Lesser than operator
    println("Lesser than of a < b is : " + (a < b));
 
    // Greater than equal to operator
    println("Greater than or Equal to of a >= b is : " + (a >= b));
     
    // Lesser than equal to operator
    println("Lesser than or Equal to of a <= b is : " + (a <= b));
 
}
}

Producción: 

Equality of   a == b is : false
Not Equals of a != b is : true
Greater than of a > b is : true
Lesser than of  a = b is : true
Lesser than or Equal to of a <= b is : false

Operadores logicos

Se utilizan para combinar dos o más condiciones/restricciones o para complementar la evaluación de la condición original en consideración. Se describen a continuación:

• El operador lógico AND(&&) devuelve verdadero cuando se cumplen ambas condiciones en consideración. De lo contrario devuelve falso. El uso de » y » es una alternativa para el operador &&. Por ejemplo, a && b devuelve verdadero cuando tanto a como b son verdaderos (es decir, distintos de cero).
• El operador lógico OR(||) devuelve verdadero cuando se cumple una (o ambas) de las condiciones consideradas. De lo contrario devuelve falso. Usar “ o ” es una alternativa para || operador. Por ejemplo, un || b devuelve verdadero si uno de a o b es verdadero (es decir, distinto de cero). Por supuesto, devuelve verdadero cuando tanto a como b son verdaderos.
• El operador lógico NOT(!) devuelve verdadero, la condición en consideración no se cumple. De lo contrario devuelve falso. Usar “ no ” es una alternativa para ! operador. Por ejemplo, !true devuelve falso.

Ejemplo:

// Scala program to demonstrate
// the Logical Operators
object Logop
{
 
def main(args: Array[String])
{
     
    // variables
    var a = false
    var b = true
     
    // logical NOT operator
    println("Logical Not of !(a && b) = " + !(a && b));
     
    // logical OR operator
    println("Logical Or of a || b = " + (a || b));
     
    // logical AND operator
    println("Logical And of a && b = " + (a && b));
 
}
}

Producción: 

Logical Not of !(a && b) = true
Logical Or of a || b = true
Logical And of a && b = false

Operadores de Asignación

Los operadores de asignación se utilizan para asignar un valor a una variable. El operando del lado izquierdo del operador de asignación es una variable y el operando del lado derecho del operador de asignación es un valor. El valor del lado derecho debe ser del mismo tipo de datos que la variable del lado izquierdo; de lo contrario, el compilador generará un error. 
A continuación se muestran diferentes tipos de operadores de asignación: 

• El operador de asignación simple (=) es el operador de asignación más simple. Este operador se utiliza para asignar el valor de la derecha a la variable de la izquierda.
• El operador Add AND Assignment (+=) se usa para agregar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
• El operador Restar Y Asignación (-=) se usa para restar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
• El operador de asignación AND de multiplicación (*=) se utiliza para multiplicar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
• El operador Divide AND Assignment (/=) se utiliza para dividir el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
• El operador Módulo Y Asignación (%=) se usa para asignar el módulo del operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
• El operador Exponente Y Asignación (**=) se utiliza para elevar la potencia del operando izquierdo al operando derecho y asignarla a la variable de la izquierda.
• El operador de desplazamiento a la izquierda Y asignación (<<=) se utiliza para realizar un desplazamiento binario a la izquierda del operando izquierdo con el operando derecho y asignarlo a la variable de la izquierda.
• El operador de desplazamiento a la derecha Y asignación (>>=) se utiliza para realizar un desplazamiento binario a la derecha del operando izquierdo con el operando derecho y asignarlo a la variable de la izquierda.
• El operador de asignación AND bit a bit (&=) se utiliza para realizar Y bit a bit del operando izquierdo con el operando derecho y asignarlo a la variable de la izquierda.
• El operador OR exclusivo bit a bit y Asignación (^=) se utiliza para realizar OR exclusivo bit a bit del operando izquierdo con el operando derecho y asignarlo a la variable de la izquierda.
• El operador OR inclusivo bit a bit y asignación (|=) se utiliza para realizar OR inclusivo bit a bit del operando izquierdo con el operando derecho y asignarlo a la variable de la izquierda.

Ejemplo: 

// Scala program to demonstrate
// the Assignments Operators
object Assignop
{
 
def main(args: Array[String])
{
     
    // variables
    var a = 50;
    var b = 40;
    var c = 0;
     
    // simple addition
    c = a + b;
    println("simple addition: c= a + b = " + c);
     
    // Add AND assignment
    c += a;
    println("Add and assignment of c += a = " + c);
     
    // Subtract AND assignment
    c -= a;
    println("Subtract and assignment of c -= a = " + c);
     
    // Multiply AND assignment
    c *= a;
    println("Multiplication and assignment of c *= a = " + c);
     
    // Divide AND assignment
    c /= a;
    println("Division and assignment of c /= a = " + c);
     
    // Modulus AND assignment
    c %= a;
    println("Modulus and assignment of c %= a = " + c);
     
    // Left shift AND assignment
    c <<= 3;
    println("Left shift and assignment of c <<= 3 = " + c);
     
    // Right shift AND assignment
    c >>= 3;
    println("Right shift and assignment of c >>= 3 = " + c);
     
    // Bitwise AND assignment
    c &= a;
    println("Bitwise And assignment of c &= 3 = " + c);
     
    // Bitwise exclusive OR and assignment
    c ^= a;
    println("Bitwise Xor and assignment of c ^= a = " + c);
     
    // Bitwise inclusive OR and assignment
    c |= a;
    println("Bitwise Or and assignment of c |= a = " + c);
}
}

Producción: 

simple addition: c= a + b = 90
Add and assignment of c += a = 140
Subtract and assignment of c -= a = 90
Multiplication and assignment of c *= a = 4500
Division and assignment of c /= a = 90
Modulus and assignment of c %= a = 40
Left shift and assignment of c <<= 3 = 320
Right shift and assignment of c >>= 3 = 40
Bitwise And assignment of c &= 3 = 32
Bitwise Xor and assignment of c ^= a = 18
Bitwise Or and assignment of c |= a = 50

Operadores bit a bit

En Scala, hay 7 operadores bit a bit que funcionan a nivel de bit o se utilizan para realizar operaciones bit a bit. Los siguientes son los operadores bit a bit: 

• AND bit a bit (&): toma dos números como operandos y hace AND en cada bit de dos números. El resultado de AND es 1 solo si ambos bits son 1.
• OR bit a bit (|): toma dos números como operandos y hace OR en cada bit de dos números. El resultado de OR es 1 cualquiera de los dos bits es 1.
• Bitwise XOR (^): toma dos números como operandos y realiza XOR en cada bit de dos números. El resultado de XOR es 1 si los dos bits son diferentes.
• Desplazamiento bit a bit a la izquierda (<<): Toma dos números, desplaza a la izquierda los bits del primer operando, el segundo operando decide el número de lugares a desplazar.
• Desplazamiento a la derecha bit a bit (>>): Toma dos números, desplaza a la derecha los bits del primer operando, el segundo operando decide el número de lugares a desplazar.
• Bitwise ones Complement (~): Este operador toma un solo número y lo utiliza para realizar la operación de complemento de 8 bits.
• Relleno de cero a la derecha con desplazamiento bit a bit (>>>): en el operador de relleno de cero a la derecha con desplazamiento, el operando izquierdo se desplaza a la derecha el número de bits especificado por el operando derecho, y los valores desplazados se rellenan con ceros.

Ejemplo: 

// Scala program to demonstrate
// the Bitwise Operators
object Bitop
{
def main(args: Array[String])
{
    // variables
    var a = 20;
    var b = 18;
    var c = 0;
     
    // Bitwise AND operator
    c = a & b;
    println("Bitwise And of a & b = " + c);
     
    // Bitwise OR operator
    c = a | b;
    println("Bitwise Or of a | b = " + c);
     
    // Bitwise XOR operator
    c = a ^ b;
    println("Bitwise Xor of a ^ b = " + c);
     
    // Bitwise once complement operator
    c = ~a;
    println("Bitwise Ones Complement of ~a = " + c);
     
    // Bitwise left shift operator
    c = a << 3;
    println("Bitwise Left Shift of a << 3 = " + c);
     
    // Bitwise right shift operator
    c = a >> 3;
    println("Bitwise Right Shift of a >> 3 = " + c);
     
    // Bitwise shift right zero fill operator
    c = a >>> 4;
    println("Bitwise Shift Right a >>> 4 = " + c);
}
}

Producción: 

Bitwise And of a & b = 16
Bitwise Or of a | b = 22
Bitwise Xor of a ^ b = 6
Bitwise Ones Complement of ~a = -21
Bitwise Left Shift of a << 3 = 160
Bitwise Right Shift of a >> 3 = 2
Bitwise Shift Right a >>> 4 = 1