Operadores en Rust

Los operadores son los símbolos que usas para hacer cuentas, comparar valores y combinar condiciones. Si ya has usado algún lenguaje parecido a C, la mayoría te resultarán conocidos.

Operadores aritméticos

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

    println!("{}", a + b); // 13
    println!("{}", a - b); // 7
    println!("{}", a * b); // 30
    println!("{}", a / b); // 3  (división entera: descarta el resto)
    println!("{}", a % b); // 1  (el resto)
}

▶ Pruébalo tú mismo

Precaución

a / b con dos enteros hace una división entera: 10 / 3 da 3, no 3.333.... Si quieres un resultado con decimales, al menos uno de los dos lados tiene que ser un número de coma flotante: 10.0 / 3.0.

Operadores de comparación

Comparan dos valores y devuelven un bool:

fn main() {
    let a = 5;
    let b = 8;

    println!("{}", a == b); // false
    println!("{}", a != b); // true
    println!("{}", a < b);  // true
    println!("{}", a > b);  // false
    println!("{}", a <= b); // true
    println!("{}", a >= b); // false
}

Los usarás todo el tiempo dentro de las condiciones de un if, que vemos en la página If…Else.

Operadores lógicos

Los operadores lógicos combinan valores booleanos o los invierten:

fn main() {
    let is_logged_in = true;
    let is_admin = false;

    println!("{}", is_logged_in && is_admin); // false: los dos deben ser true
    println!("{}", is_logged_in || is_admin); // true: al menos uno es true
    println!("{}", !is_admin);                // true: convierte false en true
}

▶ Pruébalo tú mismo

• &&, y (and): es verdadero solo si los dos lados son verdaderos.
• ||, o (or): es verdadero si al menos uno de los lados es verdadero.
• !, no (not): convierte true en false, y al revés.

Operadores de asignación

Además del = de siempre, Rust tiene operadores abreviados que actualizan una variable a partir de su valor actual:

fn main() {
    let mut score = 10;

    score += 5; // equivale a: score = score + 5
    score -= 2; // score = score - 2
    score *= 3; // score = score * 3
    score /= 2; // score = score / 2

    println!("{score}");
}

▶ Pruébalo tú mismo

Recuerda que la variable necesita mut para que cualquiera de estos compile: estás cambiando su valor.

Nota

Rust no tiene los operadores ++ ni --. Para sumarle uno a un contador, escribe count += 1. Es un carácter más, y no deja ninguna duda de lo que pasa.

Orden de las operaciones (precedencia)

Cuando una expresión tiene varios operadores, Rust no va simplemente de izquierda a derecha. Como en las matemáticas del colegio, *, / y % se hacen antes que + y -. Los operadores del mismo nivel se evalúan de izquierda a derecha. Los paréntesis siempre van primero, así que úsalos cuando quieras un orden distinto.

fn main() {
    let a = 2 + 3 * 4;            // primero *: 2 + 12
    let b = (2 + 3) * 4;          // primero los paréntesis: 5 * 4
    let c = 10 - 4 - 3;           // mismo nivel, de izquierda a derecha: (10 - 4) - 3
    let d = 17 % 5 * 2;           // mismo nivel, de izquierda a derecha: (17 % 5) * 2
    let ok = 1 + 1 == 2 && 3 > 2; // cuentas, luego comparaciones, luego &&

    println!("{a} {b} {c} {d} {ok}");
}

Salida:

14 20 3 4 true

▶ Pruébalo tú mismo

El orden completo, del primero al último, es más o menos este: aritmética (* / %, luego + -), después las comparaciones (== != < > <= >=), luego &&, luego || y, por último, los operadores de asignación (= += -= y compañía). Por eso 1 + 1 == 2 && 3 > 2 funciona sin ningún paréntesis. Aun así, si tienes que pararte a pensar en el orden, añade paréntesis. No cuestan nada y hacen que el código se lea mejor.

Precaución

No puedes encadenar comparaciones como en matemáticas. 1 < x < 5 es un error de compilación (el compilador dice “comparison operators cannot be chained”: los operadores de comparación no se pueden encadenar). Escríbelo como dos comparaciones unidas con &&: 1 < x && x < 5.

Práctica

1. Minutos y segundos

Un video dura 125 segundos. Guárdalo en una variable e imprime cuántos minutos completos y cuántos segundos sobrantes son, por ejemplo 2 minutos y 5 segundos. Pista: la división entera / te da los minutos completos, y % te da lo que sobra.

Ver solución

fn main() {
    let total_seconds = 125;

    let minutes = total_seconds / 60; // 2 (se descarta el resto)
    let seconds = total_seconds % 60; // 5 (el resto)

    println!("{minutes} minutos y {seconds} segundos");
}

Salida:

2 minutos y 5 segundos

▶ Pruébalo tú mismo

2. Llevar la puntuación

Empieza un juego con score en 10. Súmale 25, réstale 5 y luego duplícala, usando los operadores de asignación abreviados. Imprime la puntuación, si es al menos 50, y si es al menos 50 y además par. Pista: un número es par cuando score % 2 == 0.

Ver solución

fn main() {
    let mut score = 10;

    score += 25; // 35
    score -= 5;  // 30
    score *= 2;  // 60

    println!("puntuación: {score}");
    println!("¿superó el nivel? {}", score >= 50);
    println!("¿superó el nivel y es par? {}", score >= 50 && score % 2 == 0);
}

Salida:

puntuación: 60
¿superó el nivel? true
¿superó el nivel y es par? true

▶ Pruébalo tú mismo

Resumen

• Aritméticos: + - * / %. La división entera trunca: no hay decimales.
• Comparación: == != < > <= >=, y todos devuelven un bool.
• Lógicos: && (y), || (o), ! (no).
• Asignación abreviada: += -= *= /= actualizan una variable mut en el sitio. No existe ++.
• * / % van antes que + -, y las cuentas van antes que las comparaciones y que &&/||. Si tienes dudas, usa paréntesis.

Comprueba lo que aprendiste

Comprueba lo aprendido

1. ¿Cuánto da 10 / 3 cuando los dos lados son enteros?

3.333... 3 4

2. ¿Qué tipo devuelven siempre los operadores de comparación como == y <?

i32 String bool

3. ¿Qué hace falta para que score += 5; compile?

Que score esté declarada con mut Que score sea un f64 Nada especial: siempre compila

Puntuación: 0 / 3

Para leer más

• B - Operators and Symbols: The Rust Book (en inglés): una tabla de una sola página con todos los operadores de Rust y lo que hace cada uno.
• Literals and operators: Rust by Example (en inglés): ejemplos cortos y ejecutables de operadores aritméticos, lógicos y a nivel de bits.
• Expression precedence: The Rust Reference (en inglés): el orden exacto en que Rust evalúa los operadores, del primero al último.
• Operator expressions: The Rust Reference (en inglés): las reglas precisas de cada operador, incluido qué pasa cuando un entero se desborda (overflow).