02-表达式 on 编程那些事儿

01-字面量表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/literal-expr.html

r[expr.literal]

字面量表达式

r[expr.literal.syntax]

LiteralExpression ->
 CHAR_LITERAL
 | STRING_LITERAL
 | RAW_STRING_LITERAL
 | BYTE_LITERAL
 | BYTE_STRING_LITERAL
 | RAW_BYTE_STRING_LITERAL
 | C_STRING_LITERAL
 | RAW_C_STRING_LITERAL
 | INTEGER_LITERAL
 | FLOAT_LITERAL
 | `true`
 | `false`

r[expr.literal.intro] 字面量表达式是由单个 token（而非一串 token）构成的表达式，它立即且直接地指明其求值所得的值，而不是通过名称或其他求值规则来引用该值。

02-路径表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/path-expr.html

r[expr.path]

路径表达式

r[expr.path.syntax]

PathExpression ->
 PathInExpression
 | QualifiedPathInExpression

r[expr.path.intro] 在表达式上下文中使用的路径表示局部变量或项。

r[expr.path.place] 解析为局部变量或静态变量的路径表达式是位置表达式；其他路径是值表达式。

r[expr.path.safety] 使用 static mut 变量需要 unsafe 块。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


## mod globals {
## pub static STATIC_VAR: i32 = 5;
## pub static mut STATIC_MUT_VAR: i32 = 7;
## }
## let local_var = 3;
local_var;
globals::STATIC_VAR;
unsafe { globals::STATIC_MUT_VAR };
let some_constructor = Some::<i32>;
let push_integer = Vec::<i32>::push;
let slice_reverse = <[i32]>::reverse;

r[expr.path.const] 关联常量的求值方式与 const 块相同。

03-块表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/block-expr.html

r[expr.block]

块表达式

r[expr.block.syntax]

BlockExpression ->
 `{`
 InnerAttribute*
 Statements?
 `}`

BlockExpressionNoInnerAttributes ->
 `{`
 Statements?
 `}`

Statements ->
 Statement+
 | Statement+ ExpressionWithoutBlock
 | ExpressionWithoutBlock

r[expr.block.intro] 块表达式（block expression），或称块（block），是一种控制流表达式，同时也是项与变量声明的匿名命名空间作用域。

04-运算符表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/operator-expr.html

r[expr.operator]

运算符表达式

r[expr.operator.syntax]

OperatorExpression ->
 BorrowExpression
 | DereferenceExpression
 | TryPropagationExpression
 | NegationExpression
 | ArithmeticOrLogicalExpression
 | ComparisonExpression
 | LazyBooleanExpression
 | TypeCastExpression
 | AssignmentExpression
 | CompoundAssignmentExpression

r[expr.operator.intro] Rust 语言为内建类型定义了运算符。

r[expr.operator.trait] 下列许多运算符也可以使用 std::ops 或 std::cmp 中的 trait 进行重载。

05-分组表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/grouped-expr.html

r[expr.paren]

分组表达式

r[expr.paren.syntax]

GroupedExpression -> `(` Expression `)`

r[expr.paren.intro] 圆括号表达式包装单个表达式，其求值结果就是该表达式。圆括号表达式的语法是 (，然后是一个表达式（称为被括操作数），最后是 )。

06-数组与索引表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/array-expr.html

r[expr.array]

数组与索引表达式

数组表达式

r[expr.array.syntax]

ArrayExpression -> `[` ArrayElements? `]`

ArrayElements ->
 Expression ( `,` Expression )* `,`?
 | Expression `;` Expression

r[expr.array.constructor] 数组表达式用于构造数组。数组表达式有两种形式。

r[expr.array.array] 第一种形式逐一列出数组中的每个值。

r[expr.array.array-syntax] 该形式的语法是：由方括号括起的、类型一致的、以逗号分隔的表达式列表。

07-元组与索引表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/tuple-expr.html

r[expr.tuple]

元组与索引表达式

元组表达式

r[expr.tuple.syntax]

TupleExpression -> `(` TupleElements? `)`

TupleElements -> ( Expression `,` )+ Expression?

r[expr.tuple.result] 元组表达式用于构造元组值。

r[expr.tuple.intro] 元组表达式的语法是用圆括号括起的、以逗号分隔的表达式列表，这些表达式称为元组初始化操作数。

08-结构体表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/struct-expr.html

r[expr.struct]

结构体表达式

r[expr.struct.syntax]

StructExpression ->
 PathInExpression `{` (StructExprFields | StructBase)? `}`

StructExprFields ->
 StructExprField (`,` StructExprField)* (`,` StructBase | `,`?)

StructExprField ->
 OuterAttribute*
 (
 IDENTIFIER
 | (IDENTIFIER | TUPLE_INDEX) `:` Expression
 )

StructBase -> `..` Expression

r[expr.struct.intro] 结构体表达式用于创建结构体、枚举或联合体的值。它由指向结构体、枚举变体或联合体项的路径，后跟该项各字段的值组成。

09-调用表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/call-expr.html

r[expr.call]

调用表达式

r[expr.call.syntax]

CallExpression -> Expression `(` CallParams? `)`

CallParams -> Expression ( `,` Expression )* `,`?

r[expr.call.intro] 调用表达式用于调用函数。调用表达式的语法是一个表达式（称为函数操作数），后跟一个由圆括号括起、以逗号分隔的表达式列表（称为实参操作数）。

10-方法调用表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/method-call-expr.html

r[expr.method]

方法调用表达式

r[expr.method.syntax]

MethodCallExpression -> Expression `.` PathExprSegment `(`CallParams? `)`

r[expr.method.intro] 方法调用由一个表达式（接收者）、一个点号、一个表达式路径段，以及一个由圆括号括起的表达式列表组成。

11-字段访问表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/field-expr.html

r[expr.field]

字段访问表达式

r[expr.field.syntax]

FieldExpression -> Expression `.` IDENTIFIER

r[expr.field.intro] 字段表达式是一种位置表达式，求值为结构体或联合体某个字段所在的位置。

r[expr.field.mut] 当操作数可变时，字段表达式也是可变的。

r[expr.field.form] 字段表达式的语法是：一个表达式（称为容器操作数），然后是 .，最后是一个标识符。

12-闭包表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/closure-expr.html

r[expr.closure]

闭包表达式

r[expr.closure.syntax]

ClosureExpression ->
 `async`?[^cl-async-edition]
 `move`?
 ( `||` | `|` ClosureParameters? `|` )
 (Expression | `->` TypeNoBounds BlockExpression)

ClosureParameters -> ClosureParam (`,` ClosureParam)* `,`?

ClosureParam -> OuterAttribute* PatternNoTopAlt ( `:` Type )?

r[expr.closure.intro] 闭包表达式也称 lambda 表达式或 lambda，它定义一种闭包类型并求值为该类型的值。闭包表达式的语法是：可选的 async 关键字、可选的 move 关键字，然后是由管道符（|）括起、以逗号分隔的模式列表（称为闭包参数，每个参数后可选择跟 : 和类型），然后是可选的 -> 和类型（称为返回类型），最后是一个表达式（称为闭包体操作数）。

13-循环表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/loop-expr.html

r[expr.loop]

循环表达式

r[expr.loop.syntax]

LoopExpression ->
 LoopLabel? (
 InfiniteLoopExpression
 | PredicateLoopExpression
 | IteratorLoopExpression
 | LabelBlockExpression
 )

r[expr.loop.intro] Rust 支持四种循环表达式：

loop 表达式表示无限循环。
while 表达式循环直到谓词为假。
for 表达式从迭代器中取出值，循环直到迭代器为空。
[带标签的块表达式][expr.loop.block-labels]恰好运行一次循环，但允许用 break 提前退出。

r[expr.loop.break-label] 所有四种循环都支持 break 表达式和标签。

14-区间表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/range-expr.html

r[expr.range]

区间表达式

r[expr.range.syntax]

RangeExpression ->
 RangeExpr
 | RangeFromExpr
 | RangeToExpr
 | RangeFullExpr
 | RangeInclusiveExpr
 | RangeToInclusiveExpr

RangeExpr -> Expression `..` Expression

RangeFromExpr -> Expression `..`

RangeToExpr -> `..` Expression

RangeFullExpr -> `..`

RangeInclusiveExpr -> Expression `..=` Expression

RangeToInclusiveExpr -> `..=` Expression

r[expr.range.behavior] .. 和 ..= 运算符会根据下表构造 std::ops::Range（或 core::ops::Range）的某个变体对象：

15-if 表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/if-expr.html

r[expr.if]

if 表达式

r[expr.if.syntax]

IfExpression ->
 `if` Conditions BlockExpressionNoInnerAttributes
 (`else` ( BlockExpressionNoInnerAttributes | IfExpression ) )?

Conditions ->
 Expression _except [StructExpression]_
 | LetChain

LetChain -> LetChainCondition ( `&&` LetChainCondition )*

LetChainCondition ->
 Expression _except [ExcludedConditions]_
 | OuterAttribute* `let` Pattern `=` Scrutinee _except [ExcludedConditions]_

@root ExcludedConditions ->
 StructExpression
 | LazyBooleanExpression
 | RangeExpr
 | RangeFromExpr
 | RangeInclusiveExpr
 | AssignmentExpression
 | CompoundAssignmentExpression

r[expr.if.intro] if 表达式的语法是：由 && 分隔的一个或多个条件操作数，后跟一个 then 块、任意数量的 else if 条件和块，以及一个可选的结尾 else 块。

16-match 表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/match-expr.html

r[expr.match]

match 表达式

r[expr.match.syntax]

MatchExpression ->
 `match` Scrutinee `{`
 InnerAttribute*
 MatchArms?
 `}`

Scrutinee -> Expression _except [StructExpression]_

MatchArms ->
 ( MatchArm `=>` ( ExpressionWithoutBlock `,` | ExpressionWithBlock `,`? ) )*
 MatchArm `=>` Expression `,`?

MatchArm -> OuterAttribute* Pattern MatchArmGuard?

MatchArmGuard -> `if` MatchConditions

MatchConditions ->
 MatchGuardChain
 | Expression

MatchGuardChain -> MatchGuardCondition ( `&&` MatchGuardCondition )*

MatchGuardCondition ->
 Expression _except [ExcludedMatchConditions]_
 | OuterAttribute* `let` Pattern `=` MatchGuardScrutinee

MatchGuardScrutinee -> Expression _except [ExcludedMatchConditions]_

@root ExcludedMatchConditions ->
 LazyBooleanExpression
 | RangeExpr
 | RangeFromExpr
 | RangeInclusiveExpr
 | AssignmentExpression
 | CompoundAssignmentExpression

r[expr.match.intro] match 表达式根据模式进行分支。具体发生何种匹配取决于模式。

17-return 表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/return-expr.html

r[expr.return]

return 表达式

r[expr.return.syntax]

ReturnExpression -> `return` Expression?

r[expr.return.intro] return 表达式用关键字 return 表示。

r[expr.return.behavior] 求值 return 表达式会将其参数移动到当前函数调用的指定输出位置，销毁当前函数的活动帧，并将控制转移到调用者帧。

18-await 表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/await-expr.html

r[expr.await]

await 表达式

r[expr.await.syntax]

AwaitExpression -> Expression `.` `await`

r[expr.await.intro] await 表达式是一种语法构造，用于挂起由 std::future::IntoFuture 的实现所提供的计算，直到给定的 future 准备好产生一个值。

r[expr.await.construct] await 表达式的语法是：一个类型实现了 IntoFuture trait 的表达式（称为 future 操作数），然后是词法单元 .，然后是 await 关键字。

19-下划线表达式

Tue, 18 Aug 2026 08:45:00 +0800

译文 · 基于 The Rust Reference

原文链接: https://doc.rust-lang.org/reference/expressions/underscore-expr.html

r[expr.placeholder]

下划线表达式

r[expr.placeholder.syntax]

UnderscoreExpression -> `_`

r[expr.placeholder.intro] 下划线表达式用符号 _ 表示，用于在解构赋值中标记占位符。

r[expr.placeholder.lhs-assignment-only] 它们只能出现在赋值的左侧。

r[expr.placeholder.pattern] 注意，这与通配符模式不同。

_ 表达式的示例：