Booleanos en Rust

Un booleano es el tipo más sencillo que existe: solo puede valer true (verdadero) o false (falso). En Rust se llama bool, y lo usarás cada vez que tu código tenga que tomar una decisión.

Declarar un booleano

fn main() {
    let is_active = true;
    let has_error: bool = false;
    println!("activo: {is_active}, error: {has_error}");
}

▶ Pruébalo tú mismo

Rust casi siempre deduce por su cuenta que es un bool a partir de true o false, así que pocas veces tendrás que escribir el tipo.

Los booleanos suelen salir de comparaciones

En el código real no es tan común escribir true o false a mano: normalmente salen de comparar algo:

fn main() {
    let age = 20;
    let can_vote = age >= 18;
    println!("Puede votar: {can_vote}");
}

Salida:

Puede votar: true

▶ Pruébalo tú mismo

Usar booleanos en condiciones

El trabajo principal de un bool es decidir qué rama de un if se ejecuta:

fn main() {
    let is_raining = true;

    if is_raining {
        println!("Llévate un paraguas");
    } else {
        println!("Déjalo en casa");
    }
}

Vemos if a fondo en la página If…Else; esto es solo una muestra de por qué importan los booleanos.

Nota

A diferencia de otros lenguajes, Rust no trata 0, una cadena vacía o null como “falsos”. Una condición tiene que ser un bool de verdad: no se permite nada más. Así se detecta toda una familia de errores al compilar.

Combinar booleanos y la evaluación en cortocircuito

Ya conociste && (y), || (o) y ! (no) en la página de Operadores. Hay una cosa más que conviene saber sobre ellos: se detienen antes cuando la respuesta ya está decidida. Esto se llama evaluación en cortocircuito (short-circuit).

• Con a && b, si a es false, el resultado tiene que ser false, así que Rust ni siquiera mira b.
• Con a || b, si a es true, el resultado tiene que ser true, así que Rust ni siquiera mira b.

Es más que un truco de velocidad. Permite que el lado izquierdo proteja al derecho:

fn main() {
    let count = 0;
    let total = 50;

    // count es 0, así que Rust se detiene después de `count != 0` y nunca divide.
    let big_average = count != 0 && total / count > 10;
    println!("promedio alto: {big_average}");

    let is_weekend = true;
    let has_homework = true;
    // is_weekend es true, así que `!has_homework` nunca se comprueba.
    let can_relax = is_weekend || !has_homework;
    println!("puede descansar: {can_relax}");
}

Salida:

promedio alto: false
puede descansar: true

▶ Pruébalo tú mismo

Dividir entre cero haría que el programa se cayera. Como count != 0 va primero y es false, la división simplemente nunca se ejecuta. Si cambias el orden de los dos lados (total / count > 10 && count != 0), la división se ejecutaría primero. En este caso el compilador incluso lo detecta y se niega a compilar (“this operation will panic at runtime”: esta operación provocará un panic al ejecutarse); con un valor que solo llega mientras el programa corre, el programa se caería. Así que pon la “comprobación de seguridad” a la izquierda.

Consejo

Nunca necesitas == true ni == false con un booleano. Escribe if is_ready en lugar de if is_ready == true, e if !is_ready en lugar de if is_ready == false. Significa exactamente lo mismo y se lee de forma más natural.

Práctica

1. ¿Puede subir a la atracción?

Una atracción de un parque de diversiones te deja subir si mides al menos 120 cm, o si tienes al menos 8 años y vas con una persona adulta. Guarda una altura de 115, una edad de 9 y with_adult = true, e imprime si este niño puede subir. Pista: usa paréntesis para agrupar la parte de “edad y adulto”.

Ver solución

fn main() {
    let height_cm = 115;
    let age = 9;
    let with_adult = true;

    let tall_enough = height_cm >= 120;
    let can_ride = tall_enough || (age >= 8 && with_adult);

    println!("altura suficiente: {tall_enough}");
    println!("puede subir: {can_ride}");
}

Salida:

altura suficiente: false
puede subir: true

▶ Pruébalo tú mismo

2. Años bisiestos

Un año es bisiesto si es divisible entre 4 pero no entre 100, o si es divisible entre 400. Calcula un booleano is_leap para 2024, imprímelo y luego haz lo mismo con 1900. Pista: “divisible entre 4” es year % 4 == 0, y puedes hacer shadowing de year y de is_leap con un segundo let.

Ver solución

fn main() {
    let year = 2024;
    let is_leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    println!("¿{year} es bisiesto? {is_leap}");

    let year = 1900;
    let is_leap = (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
    println!("¿{year} es bisiesto? {is_leap}");
}

Salida:

¿2024 es bisiesto? true
¿1900 es bisiesto? false

▶ Pruébalo tú mismo

Resumen

• bool tiene exactamente dos valores: true o false.
• Las comparaciones (==, <, >=, …) producen booleanos.
• Las condiciones de un if deben ser un bool de verdad: no hay conversiones implícitas desde números ni cadenas.
• && y || evalúan en cortocircuito: se saltan el lado derecho cuando ya conocen la respuesta, así que pon las comprobaciones de seguridad a la izquierda.

Comprueba lo que aprendiste

Comprueba lo aprendido

1. ¿Qué tipo produce una comparación como age >= 18?

Un bool Un entero Una cadena de texto

2. En Rust, ¿puedes usar un entero como 0 directamente como condición de un if, como en otros lenguajes?

Sí, 0 se trata como false No: la condición tiene que ser un bool de verdad Sí, pero solo con i32

3. En count != 0 && total / count > 10, ¿qué pasa cuando count vale 0?

El programa se cae por dividir entre cero Rust se detiene después de count != 0 y toda la expresión es false No compila

Puntuación: 0 / 3

Para leer más

• The Boolean Type: The Rust Book (en inglés): la breve introducción oficial a bool, junto a los demás tipos básicos.
• bool: documentación de la biblioteca estándar (en inglés): todos los métodos de bool, como then y then_some, para cuando estés listo para ellos.
• Lazy boolean operators: The Rust Reference (en inglés): las reglas exactas de cómo && y || se saltan su lado derecho.
• Primitives: Rust by Example (en inglés): bool junto a los demás tipos integrados de Rust, con un ejemplo ejecutable.