Rust – Operadores

Los operadores en general se utilizan para realizar operaciones sobre valores y variables. Estos son símbolos estándar utilizados con el propósito de operaciones lógicas y aritméticas. En este artículo, veremos diferentes tipos de operadores de Rust. Los operadores le dicen al compilador o intérprete que realice una operación matemática, lógica o relacional específica. 

Los siguientes son los tipos de operadores en Rust:

• Operadores aritméticos
• Operadores de comparación
• Operadores logicos
• Operadores bit a bit
• Operadores de asignación compuesta

Operadores aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas como suma, resta, multiplicación y división.

Supongamos que A=40 y B=20

Ejemplo:

   fn main() {
   let x = 20 ;
   let y = 4;
   let mut result:i32;
     
   // addition of  two operands
   result = x + y;
   println!("Sum: {} ",result);
     
   // the difference of the values
   result = x - y;
   println!("Difference: {} ",result) ;
     
   // the product of the values
   result = x*y ;
   println!("Product: {} ",result) ;
  
   // Divide left operand by right one
   // and returns the quotient
   result = x/y ;
   println!("Quotient: {} ",result);
     
   // Divide left operand by right one
   // and returns the remainder
   result = x%y ;
   println!("Remainder: {} ",result);
}

Producción:

Sum: 24 
Difference: 16 
Product: 80 
Quotient: 5 
Remainder: 0 

Operadores de comparación

Los operadores de comparación son los operadores que comparan valores y devuelven verdadero o falso según las condiciones.

Supongamos que A=40 y B=20

Ejemplo:

fn main() {
    let a = 4;
    let b = 5;
      
    // performing a series of comparisons
    // using comparision operators
      
    // is equal to
    let c = a == b; 
      
    // is not equal to
    let d = a != b; 
      
    // is less than
    let e = a < b; 
      
    // is greater than
    let f = a > b; 
      
    // is less than or equa to
    let g = a <= a;
      
    // is greater than or equal to
    let h = a >= a;
      
    println!("a: {}, b: {}, 
    c: {0} == {1} is {}, 
    d: {0} != {1} is {}, 
    e: {0}<{1} is {}, 
    f: {0}>{1} is {}, 
    g: {0}<={0} is {}, 
    h: {0}>={0} is {}", 
    a, b, c, d, e, f, g, h);
}

Producción:

a: 4, b: 5, 
    c: 4 == 5 is false, 
    d: 4 != 5 is true, 
    e: 4<5 is true, 
    f: 4>5 is false, 
    g: 4<=4 is true, 
    h: 4>=4 is true

Operadores logicos

Los operadores lógicos se utilizan para combinar dos o más condiciones. Los operadores lógicos también devuelven un valor booleano.

Supongamos que A=1 y B=0

Ejemplo:

fn main() {
    let a = false;
    let b = true;
  
    let c = !a; 
    let d = a && b;
    let e = a || b; 
      
    println!("
    a: {}, b: {}, 
    c: !{0} is {}, 
    d: {0} && {1} is {}, 
    e: {0} || {1} is {}", 
    a, b, c, d, e);
}

Producción:

a: false, b: true, 
c: !false is true, 
d: false && true is false, 
e: false || true is true

Operadores bit a bit

Bitwise es un nivel de operaciones que implica trabajar con bits individuales, que son las unidades de datos más pequeñas en una computadora. Cada bit tiene un único valor binario: 0 o 1. 

Supongamos que A=2 y B=3

Ejemplo:

fn main() {
    let a = 1; 
    let b = 2; 
  
      // Bitwise AND, 0  (01 && 10 -> 00)
    let c = a & b;
    
    // Bitwise OR, 3  (01 || 10 -> 11)  
    let d = a | b;  
    
      // Bitwise exclusive OR, 3  (01 != 10 -> 11)
    let e = a ^ b; 
    
      // Left-shift, 4  
    let f = a << b;
    
      // 16 a->'01'+"0000" ->'10000'
    let f2 = a << 4; 
    
      // Right-shift, 0
    let g = a >> b; 
    
      // 0 '11111' -> remove 4 bits from the end ->'1'
    let g2 = 31 >> 4; 
    
      // Bitwise NOT 
    let h = !a; 
  
    println!("
    a: {a}, b: {b}, 
    c: {a} & {b} is {c}, 
    d: {a} | {b} is {d}, 
    e: {a} ^ {b} is {e},
    f: {a} << {b} is {f},
    f2: {a} << 4 is {f2},
    g: {a} >> {b} is {g},
    g2: {a} >> {b} is {g2},
    h: !{a} = {h}", 
    a=a, b=b, c=c, d=d, e=e, f=f, f2=f2, g=g, g2=g2, h=h);
    }

Producción:

a: 1, b: 2, 
c: 1 & 2 is 0, 
d: 1 | 2 is 3, 
e: 1 ^ 2 is 3,
f: 1 << 2 is 4,
f2: 1 << 4 is 16,
g: 1 >> 2 is 0,
g2: 1 >> 2 is 1,
h: !1 = -2

Operadores de asignación compuesta

Los operadores de asignación compuesta realizan la operación especificada por el operador adicional y luego asignan el resultado al operando izquierdo. Por ejemplo, una expresión de asignación compuesta como

expression1 += expression2

Supongamos que A=4

Ejemplo:

fn main() {
    let mut a = 4;
      
    println!("a is {}", a);
      
    // Arithmetic addition and assignment, 4 + 5 = 7
    a += 5; 
    println!("1: a += 5 is {}", a);
      
    // Arithmetic subtraction and assignment, 9 - 2 = 7
    a -= 2; 
    println!("2: a -= 2 is {}", a);
      
    // Arithmetic multiplication and assignment, 7 * 5 = 35
    a *= 5; 
    println!("3: a *= 5 is {}", a);
      
    // Arithmetic division and assignment, 35 / 2 = 17 not 17.5
    a /= 2; 
    println!("4: a /= 2 is {}", a);
      
    // Arithmetic remainder and assignment, 17 % 5 = 2
    a %= 5; 
    println!("5: a %= 5 is {}", a);
      
    // Bitwise AND and assignment, 10 && 10 -> 10 -> 2
    a &= 2; 
    println!("6: a &= 2 is {}", a);
      
    // Bitwise OR and assignment, 010 || 101 -> 111 -> 7
    a |= 5; 
    println!("7: a |= 5 is {}", a);
      
    // Bitwise exclusive OR and assignment, 111 ^= 010 -> 101 -> 5
    a ^= 2; 
    println!("8: a ^= 2 is {}", a);
      
    // Left-shift and assignment, '101'+'0' -> 1010 -> 10
    a <<= 1; 
    println!("9: a <<= 1 is {}", a);
      
    // Right-shift and assignment, 101̶0̶ -> 10 ->
    a >>= 2;  2
    println!("10: a >>= 2 is {}", a);
}

Producción:

a is 4
1: a += 5 is 9
2: a -= 2 is 7
3: a *= 5 is 35
4: a /= 2 is 17
5: a %= 5 is 2
6: a &= 2 is 2
7: a |= 5 is 7
8: a ^= 2 is 5
9: a <<= 1 is 10
10: a >>= 2 is 2