表达式与语句区别
核心概念
Rust 是一门"基于表达式"的语言。理解表达式(Expression)和语句(Statement)的区别是掌握 Rust 语法的关键。
- 表达式:计算并产生一个值。
5 + 3、if x > 0 { 1 } else { -1 }、{ let a = 1; a + 2 }都是表达式。 - 语句:执行操作但不产生值(或者说产生
())。let x = 5;、println!("hello");是语句。
最简单的区分方法:有分号的通常是语句,没分号的是表达式。
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 中几乎所有东西都可以是表达式。
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 中有两种主要的语句。
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); // ()
}分号的作用
分号是把表达式变成语句的"开关"。这在函数返回值和代码块中特别重要。
// 函数返回最后一个表达式的值
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 | 返回字段的值 |
| loop | loop { break 42; } | break 携带的值 |
代码块作为表达式
代码块 {} 是一种特殊的表达式。块中最后一行如果没有分号,就是整个块的值。
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);
}基本示例
展示表达式驱动编程的风格:
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。
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 代码可以用表达式驱动的风格编写,减少临时变量,让代码更简洁。最需要注意的是函数返回值——最后一行表达式不加分号就是返回值,加了分号就变成了 ()。