单元类型 () ​

什么是单元类型 ​

单元类型(Unit Type)写作 (),是一个特殊的元组——零个元素的元组。它只有一个可能的值,也写作 ()。单元类型占用 0 字节内存。

在其他语言中,不返回值的函数通常声明为 void(C/Java)或 None(Python)。在 Rust 中,所有函数都有返回值,不显式返回东西的函数实际上返回的就是 ()。

rust
fn main() {
    // 单元类型的值
    let unit: () = ();
    println!("单元值:{:?}", unit);  // ()

    // 单元类型占 0 字节
    println!("() 大小:{} 字节", std::mem::size_of::<()>());  // 0
}

函数与单元类型 ​

rust
// 这两个函数声明是完全等价的
fn greet_v1(name: &str) {
    println!("你好,{}!", name);
}

// 显式写出返回 ()
fn greet_v2(name: &str) -> () {
    println!("你好,{}!", name);
}

fn main() {
    // 没有返回值的函数实际上返回 ()
    let result1 = greet_v1("Rust");
    let result2 = greet_v2("Rust");

    println!("返回值1:{:?}", result1);  // ()
    println!("返回值2:{:?}", result2);  // ()

    // 赋值语句也返回 ()
    let mut x = 5;
    let assign_result: () = { x = 10; };
    println!("赋值结果:{:?}", assign_result);  // ()
    println!("x = {}", x);
}

语句返回单元类型 ​

在 Rust 中,语句(statement)的值就是 ()。表达式(expression)加上分号就变成了语句,它的值就从表达式的值变成了 ()。

rust
fn main() {
    // 表达式有值
    let a = {
        5 + 3  // 没有分号,这是表达式,值为 8
    };
    println!("a = {}", a);  // 8

    // 加了分号就变成语句,值变成 ()
    let b: () = {
        5 + 3;  // 有分号,这是语句,值为 ()
    };
    println!("b = {:?}", b);  // ()

    // 这就是为什么函数最后一行加不加分号很重要
    // fn add(a: i32, b: i32) -> i32 {
    //     a + b;   // 加了分号就返回 (),和声明的 i32 返回值不匹配,编译错误
    // }
}

单元类型在泛型中的应用 ​

rust
// Result<(), Error> 表示"操作要么成功(没有有意义的返回值),要么失败"
fn write_file(path: &str, content: &str) -> Result<(), String> {
    if path.is_empty() {
        Err(String::from("路径不能为空"))
    } else {
        // 假装写入成功
        println!("写入 {} 到 {}", content, path);
        Ok(())  // 成功时返回 Ok(()),没有有意义的数据
    }
}

// Option<()> 有时用来表示"存在或不存在"的信号
fn check_condition(value: i32) -> Option<()> {
    if value > 0 {
        Some(())  // 条件满足
    } else {
        None      // 条件不满足
    }
}

fn main() {
    match write_file("test.txt", "hello") {
        Ok(()) => println!("写入成功"),
        Err(e) => println!("写入失败:{}", e),
    }

    match write_file("", "hello") {
        Ok(()) => println!("写入成功"),
        Err(e) => println!("写入失败:{}", e),
    }

    // Option<()> 的用法
    if check_condition(5).is_some() {
        println!("条件满足");
    }
}

基本示例 ​

rust
use std::collections::HashMap;

fn main() {
    // HashMap<String, ()> 相当于 HashSet
    // 只关心键是否存在,值没有意义
    let mut visited: HashMap<String, ()> = HashMap::new();
    visited.insert(String::from("北京"), ());
    visited.insert(String::from("上海"), ());
    visited.insert(String::from("广州"), ());

    let city = "上海";
    if visited.contains_key(city) {
        println!("已经去过 {}", city);
    }

    // 当然,实际开发中直接用 HashSet 更好
    use std::collections::HashSet;
    let mut visited_set: HashSet<String> = HashSet::new();
    visited_set.insert(String::from("北京"));

    // 单元类型作为占位符
    // 当泛型要求提供一个类型参数,但你不需要数据时
    struct Signal<T> {
        data: T,
    }

    let empty_signal: Signal<()> = Signal { data: () };
    println!("空信号:{:?}", empty_signal.data);
}

常见问题 ​

问题一:() 和 None 有什么区别?

对比()None
类型单元类型 ()Option<T> 的一个变体
含义"没有有意义的值""值缺失"
使用场景函数无返回值、语句的值表示可选值为空
和 null 的关系不是 null是 Rust 中 null 的替代品

问题二:函数返回 () 需要显式写 return (); 吗?

不需要。函数体最后没有返回表达式时自动返回 ()。直接写空的函数体或者最后一行是语句就行。

问题三:为什么 Result<(), Error> 而不是直接返回 bool?

Result<(), Error> 比 bool 强在失败时能携带错误信息。bool 只能告诉你"成功或失败",Err(e) 能告诉你"为什么失败"。而且 Result 有 ? 运算符支持,错误处理更方便。

适用场景 ​

  • 不需要返回值的函数:打印、日志、写文件等副作用操作
  • Result<(), E>:可能失败但成功时没有有用返回值的操作
  • 泛型占位:泛型参数需要一个类型但你不需要数据时
  • 标记类型:PhantomData<()> 等标记用途
  • 信号传递:通道(channel)中发送 () 表示"事情发生了"但不需要数据

注意事项 ​

  • () 占 0 字节,使用它不会带来任何内存开销
  • 函数体最后一行加了分号就是返回 (),去掉分号才是返回表达式的值
  • println! 等宏的返回值是 ()
  • if 表达式如果没有 else 分支,它的类型就是 ()
  • 赋值表达式(x = 5)的值是 (),这和 C 语言不同(C 中赋值返回被赋的值)
  • () 实现了 Copy、Clone、Debug、Eq、Ord、Hash 等几乎所有常用 trait

总结 ​

单元类型 () 是零元素的元组,只有一个值也是 (),占用 0 字节。它在 Rust 中的角色相当于其他语言的 void——不显式返回值的函数实际返回 (),语句的值是 (),表达式加分号后值变成 ()。在泛型场景中,Result<(), E> 是最常见的用法,表示"操作要么成功要么失败,成功时不需要数据"。理解 () 的关键是认识到 Rust 中一切都有值、一切都有类型,() 就是"没有有意义的值"这个概念的具体类型表示。