布尔类型 bool ​

什么是 bool ​

bool 是 Rust 的布尔类型,只有两个值:true 和 false。它占用 1 个字节(8 位),虽然理论上 1 位就够了,但为了内存对齐和访问效率,Rust 把它设为 1 字节。

布尔值是所有条件判断和逻辑运算的基础。if 表达式、while 循环、assert! 宏的条件——这些地方都要求布尔值。

rust
fn main() {
    let is_rust_fun: bool = true;
    let is_easy = false;  // 类型自动推断为 bool

    println!("Rust 有趣吗:{}", is_rust_fun);  // true
    println!("Rust 简单吗:{}", is_easy);       // false

    // bool 占用的字节数
    println!("bool 大小:{} 字节", std::mem::size_of::<bool>());  // 1
}

逻辑运算 ​

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

    // 逻辑与(AND):两个都为 true 才是 true
    println!("true && true = {}", true && true);    // true
    println!("true && false = {}", a && b);          // false

    // 逻辑或(OR):有一个为 true 就是 true
    println!("true || false = {}", a || b);          // true
    println!("false || false = {}", false || false);  // false

    // 逻辑非(NOT):取反
    println!("!true = {}", !a);                      // false
    println!("!false = {}", !b);                     // true

    // 短路求值:&& 和 || 是短路运算符
    // 如果左边已经能决定结果,右边不会执行
    let x = false && {
        println!("这行不会执行");  // 因为 false && 任何值 都是 false
        true
    };
    println!("短路结果:{}", x);  // false
}

比较运算产生 bool ​

所有比较运算符的结果都是 bool 类型。

rust
fn main() {
    let a = 10;
    let b = 20;

    // 比较运算符
    println!("{} == {} : {}", a, b, a == b);   // false(相等)
    println!("{} != {} : {}", a, b, a != b);   // true(不等)
    println!("{} > {} : {}", a, b, a > b);     // false(大于)
    println!("{} < {} : {}", a, b, a < b);     // true(小于)
    println!("{} >= {} : {}", a, b, a >= b);   // false(大于等于)
    println!("{} <= {} : {}", a, b, a <= b);   // true(小于等于)

    // 字符串也能比较
    let s1 = "apple";
    let s2 = "banana";
    println!("'{}' < '{}' : {}", s1, s2, s1 < s2);  // true(按字典序)
}

bool 在条件判断中的使用 ​

rust
fn main() {
    let age = 20;
    let has_license = true;

    // if 表达式需要 bool
    if age >= 18 && has_license {
        println!("可以开车");
    } else {
        println!("不能开车");
    }

    // bool 作为 if 表达式的返回值
    let status = if age >= 18 { "成年" } else { "未成年" };
    println!("状态:{}", status);

    // while 循环需要 bool
    let mut count = 0;
    while count < 5 {
        count += 1;
    }
    println!("循环了 {} 次", count);

    // assert! 宏需要 bool,为 false 时 panic
    assert!(age > 0, "年龄必须大于 0");
    assert_eq!(1 + 1, 2);  // 检查两个值是否相等
}

bool 与其他类型的转换 ​

Rust 不像 C/JavaScript 那样有隐式的"真值"(truthy/falsy)概念。0、空字符串、null 在 Rust 中不会自动被当成 false。

rust
fn main() {
    // bool 转整数
    let t = true as i32;    // 1
    let f = false as i32;   // 0
    println!("true as i32 = {}", t);
    println!("false as i32 = {}", f);

    // 整数不能直接转 bool
    // let b: bool = 1 as bool;  // 编译错误
    // 需要显式比较
    let n = 1;
    let b = n != 0;  // 非零为 true
    println!("{} != 0 : {}", n, b);

    // Rust 中没有 truthy/falsy 概念
    // if 0 { ... }          // 编译错误:expected bool, found integer
    // if "" { ... }         // 编译错误:expected bool, found &str
    // if None { ... }       // 编译错误:expected bool, found Option

    // 必须显式写条件
    let list: Vec<i32> = vec![];
    if !list.is_empty() {   // 正确:用方法返回 bool
        println!("列表不为空");
    }

    let value: Option<i32> = None;
    if value.is_some() {    // 正确:用方法返回 bool
        println!("有值");
    }
}

基本示例 ​

一个简单的用户权限检查系统:

rust
struct User {
    name: String,
    is_admin: bool,
    is_active: bool,
    email_verified: bool,
}

impl User {
    // 检查用户是否有完整权限
    fn has_full_access(&self) -> bool {
        self.is_admin && self.is_active && self.email_verified
    }

    // 检查用户是否可以登录
    fn can_login(&self) -> bool {
        self.is_active && self.email_verified
    }

    // 显示状态
    fn status_summary(&self) -> String {
        format!(
            "{}: 管理员={}, 激活={}, 邮箱验证={}",
            self.name, self.is_admin, self.is_active, self.email_verified
        )
    }
}

fn main() {
    let users = vec![
        User {
            name: String::from("张三"),
            is_admin: true,
            is_active: true,
            email_verified: true,
        },
        User {
            name: String::from("李四"),
            is_admin: false,
            is_active: true,
            email_verified: false,
        },
        User {
            name: String::from("王五"),
            is_admin: false,
            is_active: false,
            email_verified: true,
        },
    ];

    for user in &users {
        println!("{}", user.status_summary());
        println!("  可以登录:{}", user.can_login());
        println!("  完整权限:{}", user.has_full_access());
        println!();
    }
}

常见问题 ​

问题一:Rust 为什么不支持 truthy/falsy?

这是类型安全的设计选择。在 JavaScript 中 if (0) 是合法的(0 被视为 falsy),但这会导致一些隐晦的 bug——比如你本来想检查一个变量是否存在,结果值恰好是 0 就被误判了。Rust 要求条件必须是 bool,消除了这类歧义。

问题二:bool 和位运算符的关系?

bool 也支持位运算符 &、|、^,它们和逻辑运算符 &&、|| 的区别是:位运算符不会短路求值。

rust
fn main() {
    // & 和 && 结果相同,但 & 不短路
    let a = true;
    let b = false;
    println!("a & b = {}", a & b);   // false(位与)
    println!("a | b = {}", a | b);   // true(位或)
    println!("a ^ b = {}", a ^ b);   // true(位异或)
}

问题三:bool 可以用在 match 中吗?

可以。

rust
fn main() {
    let flag = true;
    match flag {
        true => println!("是真的"),
        false => println!("是假的"),
    }
}

适用场景 ​

  • 条件判断:if、while、match 中的条件表达式
  • 函数返回值:表示操作是否成功、条件是否满足
  • 结构体字段:标记对象的状态(激活、可见、已删除等)
  • 过滤和搜索:iter().filter(|x| x.is_valid()) 中的谓词函数
  • 配置开关:功能开关、调试模式等布尔型配置

注意事项 ​

  • Rust 中只有 true 和 false 是布尔值,没有 truthy/falsy
  • bool 占 1 字节不是 1 位,如果需要存储大量布尔标记,考虑用位向量(bitflags crate)
  • && 和 || 是短路运算符,& 和 | 用在 bool 上不短路
  • bool 实现了 Copy、Clone、Eq、Ord 等 trait,可以直接复制和比较
  • true as i32 得到 1,false as i32 得到 0,但反过来不能直接转
  • 命名布尔变量时建议用 is_、has_、can_ 等前缀,让含义更清晰

总结 ​

bool 是 Rust 中表示真假值的基本类型,只有 true 和 false 两个值。它是所有条件判断和逻辑运算的基础,支持逻辑与(&&)、逻辑或(||)、逻辑非(!)三种运算。Rust 不支持 truthy/falsy 概念——条件表达式必须是 bool 类型,不能用整数、字符串或 Option 直接当条件。这种严格的类型要求虽然写起来多打几个字,但消除了很多隐晦的 bug。