布尔类型 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。