Option<T>
核心概念
Option<T> 是 Rust 标准库中最基础也是最重要的枚举之一,它表示一个值可能存在(Some(T))也可能不存在(None)。Rust 没有 null 的概念,所有"可能为空"的场景都必须用 Option<T> 来表达。编译器会强制你处理 None 的情况,从根本上消除了空指针引用这一类运行时错误。
// Option 在标准库中的定义
// enum Option<T> {
// Some(T), // 有值
// None, // 无值
// }
fn main() {
// 有值的 Option
let some_number: Option<i32> = Some(42);
// 无值的 Option
let no_number: Option<i32> = None;
// Option 不能直接当 T 使用
// let sum = some_number + 1; // 编译错误:不能直接对 Option<i32> 加法
// 必须先取出值
match some_number {
Some(n) => println!("数字: {}", n + 1),
None => println!("没有数字"),
}
match no_number {
Some(n) => println!("数字: {}", n),
None => println!("没有数字"),
}
}创建 Option 值
fn main() {
// 直接构造
let a: Option<i32> = Some(10);
let b: Option<String> = Some(String::from("hello"));
let c: Option<f64> = None; // None 需要类型标注
// 类型推断
let d = Some(42); // 推断为 Option<i32>
let e = Some(3.14); // 推断为 Option<f64>
let f = Some("hello"); // 推断为 Option<&str>
// 标准库方法返回 Option
let v = vec![10, 20, 30];
let first: Option<&i32> = v.first(); // Some(&10)
let fourth: Option<&i32> = v.get(3); // None
let text = "hello world";
let pos: Option<usize> = text.find('w'); // Some(6)
let missing: Option<usize> = text.find('z'); // None
let num: Option<i32> = "42".parse().ok(); // Some(42)
let bad: Option<i32> = "abc".parse().ok(); // None
println!("a={:?}, b={:?}, c={:?}", a, b, c);
println!("first={:?}, fourth={:?}", first, fourth);
println!("pos={:?}, missing={:?}", pos, missing);
println!("num={:?}, bad={:?}", num, bad);
}取值方法
安全取值
fn main() {
let val = Some(42);
let empty: Option<i32> = None;
// unwrap_or:None 时返回默认值
println!("unwrap_or: {}", val.unwrap_or(0)); // 42
println!("unwrap_or: {}", empty.unwrap_or(0)); // 0
// unwrap_or_else:None 时用闭包计算默认值(惰性求值)
println!("unwrap_or_else: {}", empty.unwrap_or_else(|| {
// 只在 None 时执行
100 * 2
}));
// unwrap_or_default:None 时返回类型的默认值
// i32 的默认值是 0,String 的默认值是 ""
println!("unwrap_or_default: {}", empty.unwrap_or_default());
let text: Option<String> = None;
println!("空字符串: '{}'", text.unwrap_or_default());
}危险取值
fn main() {
let val = Some(42);
// unwrap:有值返回值,None 时 panic
println!("unwrap: {}", val.unwrap());
// None.unwrap(); // panic!
// expect:和 unwrap 一样,但可以自定义 panic 消息
println!("expect: {}", val.expect("值不应为空"));
// None::<i32>.expect("配置项缺失"); // panic: 配置项缺失
}| 方法 | None 时行为 | 适用场景 |
|---|---|---|
unwrap() | panic | 测试代码、确定不为 None |
expect("msg") | panic 带消息 | 比 unwrap 好,错误信息更清楚 |
unwrap_or(default) | 返回默认值 | 有合理默认值时 |
unwrap_or_else(f) | 执行闭包 | 默认值计算开销大时 |
unwrap_or_default() | 返回 Default | 类型实现了 Default |
转换方法
fn main() {
let val = Some(5);
let empty: Option<i32> = None;
// map:对 Some 中的值进行转换
let doubled = val.map(|x| x * 2); // Some(10)
let doubled_none = empty.map(|x| x * 2); // None
println!("map: {:?}, {:?}", doubled, doubled_none);
// map 可以改变内部类型
let as_string = val.map(|x| x.to_string()); // Some("5")
println!("map 转类型: {:?}", as_string);
// and_then(也叫 flatmap):转换后返回 Option
// 避免 Option<Option<T>> 的嵌套
let result = val.and_then(|x| {
if x > 0 { Some(x * 10) } else { None }
});
println!("and_then: {:?}", result); // Some(50)
let fail = val.and_then(|x| {
if x > 100 { Some(x) } else { None }
});
println!("and_then 失败: {:?}", fail); // None
// filter:条件判断
let filtered = val.filter(|&x| x > 3); // Some(5)
let rejected = val.filter(|&x| x > 10); // None
println!("filter: {:?}, {:?}", filtered, rejected);
// or:如果是 None,用备选值替代
let fallback = empty.or(Some(99));
let no_fallback = val.or(Some(99)); // 已经有值,不替换
println!("or: {:?}, {:?}", fallback, no_fallback);
// as_ref:Option<T> -> Option<&T>,不消耗所有权
let text = Some(String::from("hello"));
let text_ref: Option<&String> = text.as_ref();
println!("as_ref: {:?}", text_ref);
println!("text 仍可用: {:?}", text); // text 没被消耗
}判断方法
fn main() {
let val = Some(42);
let empty: Option<i32> = None;
// is_some / is_none
println!("is_some: {}", val.is_some()); // true
println!("is_none: {}", empty.is_none()); // true
// is_some_and(Rust 1.70+):判断是否是 Some 且满足条件
let positive = val.is_some_and(|x| x > 0);
println!("is_some_and: {}", positive); // true
let too_big = val.is_some_and(|x| x > 100);
println!("is_some_and: {}", too_big); // false
let none_check = empty.is_some_and(|x| x > 0);
println!("None is_some_and: {}", none_check); // false
}模式匹配
fn grade(score: Option<u32>) -> &'static str {
match score {
Some(s) if s >= 90 => "优秀",
Some(s) if s >= 80 => "良好",
Some(s) if s >= 60 => "及格",
Some(_) => "不及格",
None => "缺考",
}
}
fn main() {
// match
let val: Option<i32> = Some(42);
match val {
Some(n) => println!("值: {}", n),
None => println!("空"),
}
// if let:只关心 Some
if let Some(n) = val {
println!("if let: {}", n);
}
// let else:不匹配时提前返回
let config: Option<&str> = Some("8080");
let Some(port_str) = config else {
println!("端口未配置");
return;
};
println!("端口: {}", port_str);
// while let
let mut stack = vec![1, 2, 3];
while let Some(top) = stack.pop() {
println!("弹出: {}", top);
}
// 成绩评定
let scores = vec![Some(95), Some(72), None, Some(88), Some(45)];
for s in &scores {
println!(" {:?} -> {}", s, grade(*s));
}
}链式操作
fn find_user(id: u32) -> Option<String> {
match id {
1 => Some(String::from("admin")),
2 => Some(String::from("editor")),
_ => None,
}
}
fn get_role(username: &str) -> Option<String> {
match username {
"admin" => Some(String::from("管理员")),
"editor" => Some(String::from("编辑")),
_ => None,
}
}
fn get_permissions(role: &str) -> Option<Vec<String>> {
match role {
"管理员" => Some(vec![
String::from("读"), String::from("写"), String::from("删除"),
]),
"编辑" => Some(vec![
String::from("读"), String::from("写"),
]),
_ => None,
}
}
fn main() {
// and_then 链式调用:任何一步返回 None,后续不执行
let perms = find_user(1)
.and_then(|name| get_role(&name))
.and_then(|role| get_permissions(&role));
match perms {
Some(p) => println!("用户1权限: {:?}", p),
None => println!("无法获取权限"),
}
// 用户不存在
let perms2 = find_user(99)
.and_then(|name| get_role(&name))
.and_then(|role| get_permissions(&role));
println!("用户99权限: {:?}", perms2); // None
// map + unwrap_or 组合
let greeting = find_user(2)
.map(|name| format!("你好, {}!", name))
.unwrap_or(String::from("你好, 访客!"));
println!("{}", greeting);
}Option 的内存优化
对于引用类型和非零类型,编译器会进行空指针优化(Null Pointer Optimization),让 Option 不占额外空间。
use std::mem;
use std::num::NonZeroU32;
fn main() {
// 引用类型:Option<&T> 和 &T 大小相同
println!("&i32: {} 字节", mem::size_of::<&i32>());
println!("Option<&i32>: {} 字节", mem::size_of::<Option<&i32>>());
// 编译器用空指针(0x0)表示 None
// Box 也享受优化
println!("Box<i32>: {} 字节", mem::size_of::<Box<i32>>());
println!("Option<Box<i32>>: {} 字节", mem::size_of::<Option<Box<i32>>>());
// NonZero 类型也享受优化
println!("NonZeroU32: {} 字节", mem::size_of::<NonZeroU32>());
println!("Option<NonZeroU32>: {} 字节", mem::size_of::<Option<NonZeroU32>>());
// 编译器用 0 表示 None
// 普通整数没有优化
println!("u32: {} 字节", mem::size_of::<u32>());
println!("Option<u32>: {} 字节", mem::size_of::<Option<u32>>());
// 需要额外空间存储判别值
}基本示例
用 Option 实现一个安全的链表查询系统:
use std::collections::HashMap;
#[derive(Debug)]
struct Employee {
name: String,
department: String,
salary: f64,
manager_id: Option<u32>, // 可能没有上级
}
struct Company {
employees: HashMap<u32, Employee>,
}
impl Company {
fn new() -> Self {
Company { employees: HashMap::new() }
}
fn add(&mut self, id: u32, name: &str, dept: &str, salary: f64, manager_id: Option<u32>) {
self.employees.insert(id, Employee {
name: name.to_string(),
department: dept.to_string(),
salary,
manager_id,
});
}
// 返回 Option:员工可能不存在
fn find(&self, id: u32) -> Option<&Employee> {
self.employees.get(&id)
}
// 获取员工姓名
fn name_of(&self, id: u32) -> Option<&str> {
self.find(id).map(|e| e.name.as_str())
}
// 获取上级姓名(两层 Option)
fn manager_name(&self, id: u32) -> Option<&str> {
self.find(id) // Option<&Employee>
.and_then(|e| e.manager_id) // Option<u32>
.and_then(|mid| self.name_of(mid)) // Option<&str>
}
// 获取管理链
fn management_chain(&self, id: u32) -> Vec<String> {
let mut chain = Vec::new();
let mut current_id = Some(id);
while let Some(cid) = current_id {
if let Some(emp) = self.find(cid) {
chain.push(emp.name.clone());
current_id = emp.manager_id;
} else {
break;
}
}
chain
}
// 部门员工列表
fn department_members(&self, dept: &str) -> Vec<(&u32, &Employee)> {
self.employees.iter()
.filter(|(_, e)| e.department == dept)
.collect()
}
// 部门平均薪资
fn department_avg_salary(&self, dept: &str) -> Option<f64> {
let members = self.department_members(dept);
if members.is_empty() {
return None;
}
let total: f64 = members.iter().map(|(_, e)| e.salary).sum();
Some(total / members.len() as f64)
}
fn report(&self, id: u32) {
println!("\n--- 员工报告 ---");
match self.find(id) {
Some(emp) => {
println!("姓名: {}", emp.name);
println!("部门: {}", emp.department);
println!("薪资: ¥{:.0}", emp.salary);
match self.manager_name(id) {
Some(name) => println!("上级: {}", name),
None => println!("上级: 无(顶层)"),
}
let chain = self.management_chain(id);
println!("管理链: {}", chain.join(" -> "));
}
None => {
println!("员工 #{} 不存在", id);
}
}
}
}
fn main() {
let mut company = Company::new();
company.add(1, "王总", "管理层", 50000.0, None);
company.add(2, "张经理", "技术部", 30000.0, Some(1));
company.add(3, "李工", "技术部", 20000.0, Some(2));
company.add(4, "赵工", "技术部", 18000.0, Some(2));
company.add(5, "陈经理", "市场部", 28000.0, Some(1));
company.add(6, "刘专员", "市场部", 12000.0, Some(5));
// 员工报告
company.report(3);
company.report(1);
company.report(99); // 不存在
// 部门统计
println!("\n--- 部门统计 ---");
for dept in &["技术部", "市场部", "财务部"] {
match company.department_avg_salary(dept) {
Some(avg) => println!("{} 平均薪资: ¥{:.0}", dept, avg),
None => println!("{}: 没有员工", dept),
}
}
}常见问题
问题一:Option 和其他语言的 null 有什么区别?
| 特性 | Option<T> | null |
|---|---|---|
| 类型安全 | 编译器强制处理 None | 运行时才发现 |
| 显式标记 | 类型签名标明可能为空 | 任何引用可能是 null |
| 使用方式 | 必须解包后才能用值 | 直接使用,可能崩溃 |
| 性能 | 引用类型零开销 | 通常零开销 |
问题二:什么时候用 unwrap?
只在你百分百确定值是 Some 时用 unwrap,通常是在测试代码或原型验证中。生产代码建议用 expect 并附带清晰的错误消息,或者用 unwrap_or、match 等安全方式。
问题三:Option 和 Result 有什么关系?
Option<T> 表示"有值或没有值",Result<T, E> 表示"成功或失败(带错误信息)"。Option 可以通过 .ok_or(err) 转为 Result,Result 可以通过 .ok() 转为 Option。
问题四:Option<&T> 真的没有额外开销吗?
是的。编译器利用"引用不可能为空"这一事实,用空指针(0x0)表示 None,不需要额外的判别值。Option<&T> 和 &T 大小完全相同。
适用场景
- 可选值:函数参数或结构体字段可能缺失
- 查找操作:在集合中查找元素,可能找不到
- 解析操作:字符串转数字可能失败
- 链式数据:链表节点的 next 指针
注意事项
Option是 Rust 替代 null 的方式,编译器强制处理 None- 生产代码避免使用
unwrap,优先用match、if let、unwrap_or map转换 Some 中的值,and_then避免 Option 嵌套as_ref()将&Option<T>转为Option<&T>,避免消耗所有权- 引用类型和 NonZero 类型的 Option 有空指针优化,不占额外空间
Option和Result可以互相转换is_some_and(Rust 1.70+)简化了判断逻辑
总结
Option<T> 是 Rust 中替代 null 的核心枚举,由 Some(T) 和 None 两个变体组成。编译器强制在使用值之前处理 None 的情况,从源头消除了空指针异常。Option 提供了丰富的方法进行安全取值(unwrap_or、unwrap_or_default)、转换(map、and_then)、判断(is_some、is_some_and)和组合(or、filter)。通过 and_then 可以实现链式操作,任何一步返回 None 后续就不执行。对于引用类型,Option<&T> 和 &T 大小相同,没有运行时开销。在 Rust 中,任何可能缺失的值都应该用 Option 表达。