表达式返回与分号 ​

核心规则 ​

Rust 函数的返回值有两种方式:尾部表达式和 return 语句。尾部表达式是函数体最后一行不加分号的表达式,它的值就是函数的返回值。这是 Rust 最常用也最惯用的返回方式。

关键点:分号决定了一行代码是表达式还是语句。不加分号是表达式(有值),加了分号变成语句(值被丢弃,返回 ())。

rust
// 尾部表达式返回(推荐)
fn add(a: i32, b: i32) -> i32 {
    a + b  // 没有分号,这是表达式,值被当作返回值
}

// 加了分号就变成语句,返回 (),和声明的 i32 类型冲突
// fn add_wrong(a: i32, b: i32) -> i32 {
//     a + b;  // 编译错误:expected `i32`, found `()`
// }

// return 语句返回(加分号)
fn add_with_return(a: i32, b: i32) -> i32 {
    return a + b;  // return 是语句,必须加分号
}

fn main() {
    println!("{}", add(3, 4));             // 7
    println!("{}", add_with_return(3, 4)); // 7
}

尾部表达式 vs return ​

特性尾部表达式return 语句
分号不加分号必须加分号
位置只能在函数体最后可以在任何位置
惯用程度Rust 推荐的方式用于提前返回
语义"这是函数的结果""现在就退出函数"
rust
// 惯用写法:末尾用表达式,中间提前退出用 return
fn classify(n: i32) -> &'static str {
    // 提前返回用 return(加分号)
    if n < 0 {
        return "负数";
    }

    // 最后的值用尾部表达式(不加分号)
    if n == 0 {
        "零"
    } else {
        "正数"
    }
}

fn main() {
    println!("{}", classify(-5));  // 负数
    println!("{}", classify(0));   // 零
    println!("{}", classify(10));  // 正数
}

各种表达式作为返回值 ​

很多结构在 Rust 中都是表达式,都可以放在函数末尾作为返回值。

rust
// if 表达式作为返回值
fn abs(n: i32) -> i32 {
    if n >= 0 { n } else { -n }
}

// match 表达式作为返回值
fn day_type(day: &str) -> &'static str {
    match day {
        "周六" | "周日" => "周末",
        _ => "工作日",
    }
}

// 代码块表达式作为返回值
fn compute(x: i32) -> i32 {
    let temp = x * 2;
    // 代码块的最后一行(无分号)是块的值
    {
        let adjusted = temp + 10;
        adjusted * 3
    }
}

// 方法调用链作为返回值
fn format_name(first: &str, last: &str) -> String {
    format!("{} {}", first, last)
        .trim()
        .to_uppercase()
}

fn main() {
    println!("|-5| = {}", abs(-5));
    println!("周六是{}", day_type("周六"));
    println!("compute(3) = {}", compute(3));
    println!("名字:{}", format_name("zhang", "san"));
}

分号的影响 ​

rust
fn main() {
    // 代码块中分号的影响
    let a = {
        let x = 5;
        x + 1      // 无分号:块的值是 6
    };
    println!("a = {}", a);  // 6

    let b = {
        let x = 5;
        x + 1;     // 有分号:表达式变成语句,块的值是 ()
    };
    println!("b = {:?}", b);  // ()

    // if 表达式中分号的影响
    let c = if true {
        42         // 无分号:表达式值 42
    } else {
        0
    };
    println!("c = {}", c);  // 42

    // 在赋值中,整个 if 后面的分号是终止 let 语句的
    let d = if true { 42 } else { 0 };  // 分号终止 let 语句,不影响 if 表达式
    println!("d = {}", d);  // 42
}

常见错误与修复 ​

rust
// 错误一:末尾表达式多加了分号
fn area_wrong(w: f64, h: f64) -> f64 {
    // w * h;  // 编译错误:expected `f64`, found `()`
    w * h      // 正确:去掉分号
}

// 错误二:return 后面忘加分号
fn area_return(w: f64, h: f64) -> f64 {
    // return w * h  // 编译错误:expected `;`
    return w * h;    // 正确:return 语句要加分号
}

// 错误三:if 分支中混用分号
fn max_val(a: i32, b: i32) -> i32 {
    if a > b {
        a          // 无分号,作为 if 表达式的值
    } else {
        b          // 无分号,和上面的分支类型一致
    }
    // 注意:两个分支要么都加分号(返回 ()),要么都不加
}

fn main() {
    println!("{}", area_wrong(3.0, 4.0));
    println!("{}", area_return(3.0, 4.0));
    println!("{}", max_val(10, 20));
}

基本示例 ​

展示不同返回方式的实际应用:

rust
// 纯尾部表达式风格
fn fibonacci(n: u32) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let mut a: u64 = 0;
            let mut b: u64 = 1;
            for _ in 2..=n {
                let temp = a + b;
                a = b;
                b = temp;
            }
            b  // 尾部表达式返回
        }
    }
}

// 混合使用 return 和尾部表达式
fn grade(score: f64) -> Result<&'static str, String> {
    // 参数验证:提前返回错误
    if score < 0.0 || score > 100.0 {
        return Err(format!("分数 {} 不在 0-100 范围内", score));
    }

    // 正常逻辑:尾部表达式返回
    Ok(if score >= 90.0 {
        "优秀"
    } else if score >= 80.0 {
        "良好"
    } else if score >= 60.0 {
        "及格"
    } else {
        "不及格"
    })
}

fn main() {
    // fibonacci
    for i in 0..10 {
        print!("{} ", fibonacci(i));
    }
    println!();

    // grade
    let scores = [95.0, 82.0, 55.0, -10.0, 110.0];
    for &s in &scores {
        match grade(s) {
            Ok(g) => println!("{:.0} 分 -> {}", s, g),
            Err(e) => println!("错误:{}", e),
        }
    }
}

常见问题 ​

问题一:什么时候用尾部表达式,什么时候用 return?

Rust 社区的惯例是:函数末尾用尾部表达式,只在需要提前退出(参数验证、错误处理、循环中找到结果)时用 return。

问题二:为什么 Rust 选择这种设计?

因为 Rust 是基于表达式的语言——if、match、代码块都是表达式。让函数体的最后一个表达式自然地成为返回值,和语言的整体设计一致。

问题三:return 和尾部表达式的性能有差别吗?

没有。编译器生成的代码完全一样,两者只是语法风格上的区别。

问题四:闭包也遵循同样的规则吗?

是的。闭包体的最后一个表达式(不加分号)也是闭包的返回值。

rust
fn main() {
    let double = |x: i32| x * 2;       // 单行闭包不加分号
    let triple = |x: i32| { x * 3 };   // 代码块闭包,最后一行无分号
    println!("{}, {}", double(5), triple(5));
}

适用场景 ​

  • 尾部表达式:函数末尾的正常返回,所有简单函数
  • return 语句:参数验证失败时的提前返回、循环中找到结果时的提前退出、复杂条件分支中的提前返回

注意事项 ​

  • 尾部表达式不加分号,加了就变成 ()
  • return 语句必须加分号
  • 代码块、if、match 作为返回值时,内部最后一行也不加分号
  • 所有返回路径(return 和尾部表达式)的类型必须一致
  • Clippy 会对末尾多余的 return 发出警告(needless_return)
  • 在闭包中也遵循同样的规则

总结 ​

Rust 的函数返回值有两种写法:尾部表达式(不加分号)和 return 语句(加分号)。分号是关键——它把表达式变成语句,值从有意义的返回值变成 ()。Rust 社区的惯例是在函数末尾用尾部表达式返回值,只在需要提前退出时用 return。这个设计和 Rust 作为"基于表达式的语言"一脉相承——if、match、代码块都是表达式,函数体的最后一个表达式自然就是返回值。理解分号的作用是避免 Rust 初学者最常见编译错误的关键。