Operadores y Literales

Enteros 1, flotantes 1.2, caractéres 'a', cadenas "abc", booleanos true y el tipo unitario () se puede expresar con literales.

Los enteros pueden, alternativamente, expresarse utilizando notación hexadecimal, octal o binariausando estos prefijos respectivamente: 0x, 0o o 0b.

Se pueden insertar guíones bajos en literales numéricos para mejorar la legibilidad, por ejemplo,1_000 es lo mismo que 1000, y 0.000_001 es lo mismo que 0.000001.

Rust también admite notación E científica, e.g. 1e6, 7.6e-4. El tipo asociado es f64.

Necesitamos decirle al compilador el tipo de literales que usamos. Por ahora, lo haremosusando el sufijo u32 para indicar que el literal es un entero sin signo de 32 bits , y el sufijo i32 para indicar que es un entero con signo de 32 bits.

Los operadores disponibles y su precedencia en Rust es similar a otros lenguajes como C.

fn main() {
    // Suma de enteros    println!("1 + 2 = {}", 1u32 + 2);

    // Resta de enteros    println!("1 - 2 = {}", 1i32 - 2);
    // TAREA ^ Intenta cambiar `1i32` a `1u32` para ver por qué el tipo es importante

    // Notación científica    println!("1e4 es {}, -2.5e-3 es {}", 1e4, -2.5e-3);

    // Lógica booleana de corto circuito    println!("true Y false es {}", true && false);
    println!("true O false es {}", true || false);
    println!("NOT true es {}", !true);

    // Operaciones sobre bits    println!("0011 AND 0101 es {:04b}", 0b0011u32 & 0b0101);
    println!("0011 OR 0101 es {:04b}", 0b0011u32 | 0b0101);
    println!("0011 XOR 0101 es {:04b}", 0b0011u32 ^ 0b0101);
    println!("1 << 5 es {}", 1u32 << 5);
    println!("0x80 >> 2 es 0x{:x}", 0x80u32 >> 2);

    // ¡Usa guiones bajos para mejorar la legibilidad!
    println!(" Un millón se escribe como {}", 1_000_000u32);
}