Operadores de Rust

En Rust, ya sea en cálculos numéricos simples, juicios lógicos, o en operaciones más complejas como la coincidencia de patrones y las operaciones de bits, los operadores desempeñan un papel fundamental.

Rust admite tanto los operadores comunes de los lenguajes de la familia C con los que estamos familiarizados, como también proporciona algunos símbolos de operación únicos. Dominar estos operadores no solo hace que el código sea más conciso y eficiente, sino que también te ayuda a comprender mejor la semántica de Rust.

1. Operadores aritméticos

Operador Descripción Ejemplo Resultado
+ Suma 5 + 2 7
- Resta 5 - 2 3
* Multiplicación 5 * 2 10
/ División (entera) 5 / 2 2(entero)
% Módulo (resto) 5 % 2 1

Ejemplo

fn main() {
    let a = 10;
    let b = 3;

    println!("a + b = {}", a + b);
    println!("a - b = {}", a - b);
    println!("a * b = {}", a * b);
    println!("a / b = {}", a / b);
    println!("a % b = {}", a % b);
}

Salida:

a + b = 13
a - b = 7
a * b = 30
a / b = 3
a % b = 1

Rust no tiene**o^un operador de potenciación como este (nota:^es XOR a nivel de bits). Si necesitas realizar una potenciación, debes usar los métodos incorporados pow o powf:

  • Los tipos de enterosusan.pow(exp: u32)
  • Los tipos de punto flotanteusan.powf(exp: f64)

Potencia de enteros

Ejemplo

fn main() {
    let base: i32 = 2;
    let result = base.pow(3); // 2^3

    println!("2^3 = {}", result);
}

Salida:

2^3 = 8

Potencia de números de punto flotante

Ejemplo

fn main() {
    let base: f64 = 2.0;
    let result = base.powf(2.5); // 2^2.5

    println!("2^2.5 = {}", result);
}

Salida:

2^2.5 = 5.656854249492381

2. Operadores relacionales (de comparación)

Operador Descripción Ejemplo Resultado
== Igual a 5 == 5 true
!= No igual a 5 != 2 true
> Mayor que 5 > 2 true
< Menor que 5 < 2 false
>= Mayor o igual que 5 >= 5 true
<= Menor o igual que 2 <= 5 true

Ejemplo

fn main() {
    let x = 5;
    let y = 10;

    println!("x == y : {}", x == y);
    println!("x != y : {}", x != y);
    println!("x > y  : {}", x > y);
    println!("x < y  : {}", x < y);
    println!("x >= y : {}", x >= y);
    println!("x <= y : {}", x <= y);
}

Salida:

x == y : false
x != y : true
x > y  : false
x < y  : true
x >= y : false
x <= y : true

3. Operadores lógicos

Operador Descripción Ejemplo Resultado
&& Y lógico (AND) true && false false
|| O lógico (OR) true || false true
! NO lógico (NOT) !true false

Ejemplo

fn main() {
    let a = true;
    let b = false;

    println!("a && b = {}", a && b);
    println!("a || b = {}", a || b);
    println!("!a = {}", !a);
}

Salida:

a && b = false
a || b = true
!a = false

4. Operadores de bits

Operador Descripción Ejemplo Resultado
& Y a nivel de bits (AND) 5 & 3 1
| O a nivel de bits (OR) 5 | 3 7
^ XOR a nivel de bits 5 ^ 3 6
! Complemento a nivel de bits (NOT) !5 -6
<< Desplazamiento a la izquierda 5 << 1 10
>> Desplazamiento a la derecha 5 >> 1 2

Ejemplo

fn main() {
    let x: u8 = 0b1010; // 10
    let y: u8 = 0b1100; // 12

    println!("x & y = {:b}", x & y);
    println!("x | y = {:b}", x | y);
    println!("x ^ y = {:b}", x ^ y);
    println!("!x = {:b}", !x);
    println!("x << 1 = {:b}", x << 1);
    println!("x >> 1 = {:b}", x >> 1);
}

Salida:

x & y = 1000
x | y = 1110
x ^ y = 110
!x = 11110101
x << 1 = 10100
x >> 1 = 101

5. Operadores de asignación y asignación compuesta

Operador Descripción Ejemplo Resultado
= Asignación let mut x = 5; x = 3; x = 3
+= Suma y asignación x += 2 x = x + 2
-= Resta y asignación x -= 2 x = x - 2
*= Multiplicación y asignación x *= 2 x = x * 2
/= División y asignación x /= 2 x = x / 2
%= Módulo y asignación x %= 2 x = x % 2
&= |= ^= <<= >>= Asignación compuesta con operaciones de bits x &= 2 Similar a

Ejemplo

fn main() {
    let mut n = 5;

    n += 3;
    println!("n += 3 -> {}", n);

    n *= 2;
    println!("n *= 2 -> {}", n);

    n >>= 1;
    println!("n >>= 1 -> {}", n);
}

Salida:

n += 3 -> 8
n *= 2 -> 16
n >>= 1 -> 8

6. Otros operadores comunes

Operador Descripción Ejemplo
.. Rango (excluye el extremo derecho) 0..5Produce del 0 al 4
..= Rango (incluye el extremo derecho) 0..=5Produce del 0 al 5
as Conversión de tipos 5 as f32
? Propagación de errores (enResult) some()?;
* Desreferencia *ptr
& Tomar referencia &x
ref Vincular como referencia let ref y = x;

Ejemplo

fn main() {
    let x = 5;
    let y = x as f64;

    for i in 1..4 {
        print!("{} ", i);
    }
    println!();

    for i in 1..=3 {
        print!("{} ", i);
    }
    println!();

    let a = 10;
    let b = &a;
    println!("*b = {}", *b);
}

Salida:

1 2 3 
1 2 3 
*b = 10
Otras extensiones