Option<T> ​

核心概念 ​

Option<T> 是 Rust 标准库中最基础也是最重要的枚举之一,它表示一个值可能存在(Some(T))也可能不存在(None)。Rust 没有 null 的概念,所有"可能为空"的场景都必须用 Option<T> 来表达。编译器会强制你处理 None 的情况,从根本上消除了空指针引用这一类运行时错误。

rust
// 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 值 ​

rust
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);
}

取值方法 ​

安全取值 ​

rust
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());
}

危险取值 ​

rust
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

转换方法 ​

rust
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 没被消耗
}

判断方法 ​

rust
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
}

模式匹配 ​

rust
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));
    }
}

链式操作 ​

rust
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 不占额外空间。

rust
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 实现一个安全的链表查询系统:

rust
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 表达。