表达式与语句区别 ​

核心概念 ​

Rust 是一门"基于表达式"的语言。理解表达式(Expression)和语句(Statement)的区别是掌握 Rust 语法的关键。

  • 表达式:计算并产生一个值。5 + 3、if x > 0 { 1 } else { -1 }、{ let a = 1; a + 2 } 都是表达式。
  • 语句:执行操作但不产生值(或者说产生 ())。let x = 5;、println!("hello"); 是语句。

最简单的区分方法:有分号的通常是语句,没分号的是表达式。

rust
fn main() {
    // 语句:用 let 绑定变量,以分号结尾,不产生可用的值
    let x = 5;

    // 表达式:计算出一个值
    let y = {
        let a = 3;
        a + 2  // 没有分号,这是表达式,返回 5
    };
    println!("y = {}", y);  // 5

    // 加了分号就变成语句,返回 ()
    let z = {
        let a = 3;
        a + 2;  // 有分号,变成语句,返回 ()
    };
    println!("z = {:?}", z);  // ()
}

什么是表达式 ​

表达式会计算出一个值。Rust 中几乎所有东西都可以是表达式。

rust
fn main() {
    // 字面量是表达式
    let a = 42;           // 42 是表达式
    let b = "hello";      // "hello" 是表达式
    let c = true;         // true 是表达式

    // 算术运算是表达式
    let d = 3 + 4 * 2;    // 表达式,值为 11

    // 函数调用是表达式
    let e = String::from("rust");  // 表达式,返回 String

    // 代码块是表达式
    let f = {
        let x = 10;
        let y = 20;
        x + y  // 最后一行无分号,作为块的返回值
    };
    println!("f = {}", f);  // 30

    // if 是表达式
    let g = if a > 0 { "正" } else { "非正" };

    // match 是表达式
    let h = match a {
        0 => "零",
        1..=100 => "正常范围",
        _ => "其他",
    };

    println!("{}, {}", g, h);
}

什么是语句 ​

语句执行操作但不返回有用的值。Rust 中有两种主要的语句。

rust
fn main() {
    // 声明语句:let 绑定
    let x = 5;  // 这是语句

    // 在 Rust 中 let 语句不返回值,所以不能这样写:
    // let a = (let b = 6);  // 编译错误

    // 表达式语句:表达式后面加分号
    x + 1;         // 表达式 x+1 加了分号,变成语句,值被丢弃
    println!("hello");  // println! 的返回值 () 被丢弃

    // 语句的返回类型是 ()
    let result: () = {
        let _y = 10;  // let 语句
    };
    println!("{:?}", result);  // ()
}

分号的作用 ​

分号是把表达式变成语句的"开关"。这在函数返回值和代码块中特别重要。

rust
// 函数返回最后一个表达式的值
fn add(a: i32, b: i32) -> i32 {
    a + b  // 没分号:这是表达式,作为返回值
}

// 加了分号就变成语句,返回 (),和声明的返回类型冲突
// 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
}

常见的表达式类型 ​

表达式类型示例说明
字面量42、"hello"、true最基本的表达式
算术运算a + b、x * 2运算符组合
比较运算a > b、x == 0返回 bool
逻辑运算a && b、!flag返回 bool
代码块{ let x = 1; x + 2 }最后一行无分号为返回值
if 表达式if x > 0 { 1 } else { -1 }返回分支的值
match 表达式match x { 1 => "a", _ => "b" }返回匹配分支的值
函数调用foo(42)返回函数的返回值
方法调用s.len()返回方法的返回值
闭包|x| x + 1闭包本身也是表达式
元组构造(1, 2, 3)返回元组
数组构造[1, 2, 3]返回数组
索引arr[0]返回元素的值
字段访问point.x返回字段的值
looploop { break 42; }break 携带的值

代码块作为表达式 ​

代码块 {} 是一种特殊的表达式。块中最后一行如果没有分号,就是整个块的值。

rust
fn main() {
    // 代码块表达式
    let value = {
        let width = 10;
        let height = 5;
        width * height  // 无分号,这个值就是块的返回值
    };
    println!("面积:{}", value);  // 50

    // 可以在任何需要值的地方使用代码块
    let description = {
        let temp = 28;
        if temp > 30 {
            "热"
        } else if temp > 20 {
            "舒适"
        } else {
            "凉"
        }
    };
    println!("天气:{}", description);

    // 代码块用于限制变量作用域
    let result = {
        let temp_data = vec![1, 2, 3, 4, 5];
        temp_data.iter().sum::<i32>()
        // temp_data 在这里被释放
    };
    println!("总和:{}", result);
}

基本示例 ​

展示表达式驱动编程的风格:

rust
struct Rectangle {
    width: f64,
    height: f64,
}

impl Rectangle {
    fn new(width: f64, height: f64) -> Self {
        // 结构体构造也是表达式
        Rectangle { width, height }
    }

    fn area(&self) -> f64 {
        // 表达式直接作为返回值
        self.width * self.height
    }

    fn perimeter(&self) -> f64 {
        2.0 * (self.width + self.height)
    }

    fn classify(&self) -> &'static str {
        // match 表达式作为返回值
        match (self.width == self.height, self.area()) {
            (true, _) => "正方形",
            (_, area) if area > 100.0 => "大矩形",
            (_, area) if area > 10.0 => "中矩形",
            _ => "小矩形",
        }
    }

    fn description(&self) -> String {
        // 整个 format! 是表达式
        format!("{}({:.1} x {:.1},面积={:.1},周长={:.1})",
            self.classify(),
            self.width, self.height,
            self.area(), self.perimeter()
        )
    }
}

fn main() {
    let shapes = vec![
        Rectangle::new(5.0, 5.0),
        Rectangle::new(15.0, 8.0),
        Rectangle::new(2.0, 3.0),
        Rectangle::new(20.0, 10.0),
    ];

    for shape in &shapes {
        println!("{}", shape.description());
    }

    // 表达式驱动的数据处理
    let total_area: f64 = shapes.iter()
        .map(|r| r.area())
        .sum();

    let largest = shapes.iter()
        .max_by(|a, b| a.area().partial_cmp(&b.area()).unwrap())
        .map(|r| r.description())
        .unwrap_or_else(|| String::from("无"));

    println!("\n总面积:{:.1}", total_area);
    println!("最大的:{}", largest);
}

常见问题 ​

问题一:为什么 let 不是表达式?

在 C 语言中赋值 x = 5 是表达式,可以写 a = b = 5。Rust 的设计者有意让 let 成为语句,避免了 if (x = 5) 这类把赋值误写成判断的 bug。

问题二:分号加错了会怎样?

如果函数声明了返回值类型,但最后一行表达式加了分号,编译器会报类型不匹配错误:expected i32, found ()。这是初学 Rust 时最常见的错误之一。

问题三:return 和尾部表达式有什么区别?

功能上一样——都是返回值。区别是 return 可以在函数中间提前返回,而尾部表达式只能在最后。Rust 的惯例是在函数末尾用表达式返回值,只在提前返回时用 return。

rust
fn classify(n: i32) -> &'static str {
    if n < 0 {
        return "负数";  // 提前返回用 return
    }

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

fn main() {
    println!("{}", classify(-5));
    println!("{}", classify(0));
    println!("{}", classify(10));
}

问题四:赋值操作是表达式还是语句?

赋值 x = 5 在 Rust 中是表达式,但它的返回值是 (),不是被赋的值。所以 let a = (x = 5) 可以编译,但 a 的类型是 ()。

适用场景 ​

  • 函数返回值:用尾部表达式替代 return
  • 条件赋值:用 if 表达式根据条件选择值
  • 代码块赋值:用代码块做复杂计算并返回结果
  • match 赋值:用 match 表达式根据模式返回不同的值
  • 链式调用:迭代器的 map、filter、collect 链

注意事项 ​

  • 函数最后一行表达式不加分号才是返回值
  • let 是语句,不能嵌套赋值(let a = let b = 5 不合法)
  • 分号把表达式变成语句,值变成 ()
  • if 作为表达式时所有分支返回类型必须一致
  • 代码块的值是最后一行(无分号的)表达式
  • Rust 惯例:函数末尾用表达式返回值,提前返回才用 return
  • 赋值表达式 x = val 返回 (),不是 val

总结 ​

Rust 中的表达式计算并产生一个值,语句执行操作但不产生有用的值(返回 ())。分号是把表达式变成语句的关键——加了分号,值就被丢弃了。几乎所有东西都可以是表达式:if、match、代码块 {}、loop 等都能产生值。这让 Rust 代码可以用表达式驱动的风格编写,减少临时变量,让代码更简洁。最需要注意的是函数返回值——最后一行表达式不加分号就是返回值,加了分号就变成了 ()。