块表达式

^语法
BlockExpression :
   {
      InnerAttribute^*
      Statements^?
   }

语句 :
      Statement⁺
   | Statement⁺ ExpressionWithoutBlock
   | ExpressionWithoutBlock

块表达式，或称作块，是一种控制流表达式和用于条目与变量声明的匿名命名空间作用域。作为一种控制流表达式，块会顺序执行其组成部分的非条目声明语句，然后执行其最终的可选表达式。作为一个匿名命名空间作用域，条目声明仅在块自身内部的作用域中，而由 let 语句声明的变量的作用域从下一条语句开始，直到块的末尾。有关更多详细信息，请参阅作用域章节。

块的语法是 {，然后是任意数量的内部属性，然后是任意数量的语句，然后是一个可选的表达式（称为最终操作数），最后是 }。

语句通常需要在后面跟一个分号，但有两个例外：

条目声明语句不需要在后面跟分号。
表达式语句通常需要在后面跟分号，除非其外部表达式是控制流表达式。

此外，语句之间允许有多余的分号，但这些分号不会影响语义。

当评估块表达式时，每条语句（条目声明语句除外）都会按顺序执行。然后，如果给定了最终操作数，则执行它。

块的类型是最终操作数的类型，如果省略了最终操作数，则为 ()。

#![allow(unused)]
fn main() {
fn fn_call() {}
let _: () = {
    fn_call();
};

let five: i32 = {
    fn_call();
    5
};

assert_eq!(5, five);
}

注意：作为控制流表达式，如果块表达式是表达式语句的外部表达式，则期望的类型是 ()，除非它紧接着跟一个分号。

块始终是值表达式，并在值表达式上下文中评估最后一个操作数。

注意：这可以用于在真正需要时强制移动值。例如，以下示例在调用 consume_self 时失败，因为结构体在块表达式中已从 s 中移出。

#![allow(unused)]
fn main() {
struct Struct;

impl Struct {
    fn consume_self(self) {}
    fn borrow_self(&self) {}
}

fn move_by_block_expression() {
    let s = Struct;

    // Move the value out of `s` in the block expression.
    (&{ s }).borrow_self();

    // Fails to execute because `s` is moved out of.
    s.consume_self();
}
}

`async` 块

^语法
AsyncBlockExpression :
async move^? BlockExpression

async 块是块表达式的一种变体，它会评估为一个 future。块的最终表达式（如果存在）决定了 future 的结果值。

执行 async 块类似于执行闭包表达式：它的直接效果是生成并返回一个匿名类型。然而，闭包返回的类型实现了 std::ops::Fn traits 中的一个或多个，而 async 块返回的类型实现了 std::future::Future trait。此类型的实际数据格式未指定。

注意： rustc 生成的 future 类型大致等同于一个枚举，每个 await 点有一个变体，每个变体存储从其对应点恢复所需的数据。

版本差异：Async 块仅从 Rust 2018 开始可用。

#![allow(unused)]
fn main() {
loop {
    async move {
        break; // error[E0267]: `break` inside of an `async` block
    }
}
}

`const` 块

^语法
ConstBlockExpression :
const BlockExpression

const 块是块表达式的一种变体，其主体在编译时而不是运行时评估。

Const 块允许您定义常量值，而无需定义新的常量条目，因此它们有时也称为内联常量。它还支持类型推断，因此无需像常量条目那样指定类型。

与自由常量条目不同，Const 块具有引用作用域内的泛型参数的能力。它们被脱糖为作用域内具有泛型参数的常量条目（类似于关联常量，但没有与之关联的 trait 或类型）。例如，以下代码

#![allow(unused)]
fn main() {
fn foo<T>() -> usize {
    const { std::mem::size_of::<T>() + 1 }
}
}

等效于

#![allow(unused)]
fn main() {
fn foo<T>() -> usize {
    {
        struct Const<T>(T);
        impl<T> Const<T> {
            const CONST: usize = std::mem::size_of::<T>() + 1;
        }
        Const::<T>::CONST
    }
}
}

如果 const 块表达式在运行时执行，则保证常量会被评估，即使其返回值被忽略

#![allow(unused)]
fn main() {
fn foo<T>() -> usize {
    // If this code ever gets executed, then the assertion has definitely
    // been evaluated at compile-time.
    const { assert!(std::mem::size_of::<T>() > 0); }
    // Here we can have unsafe code relying on the type being non-zero-sized.
    /* ... */
    42
}
}

如果 const 块表达式未在运行时执行，则可能会也可能不会被评估

#![allow(unused)]
fn main() {
if false {
    // The panic may or may not occur when the program is built.
    const { panic!(); }
}
}

`unsafe` 块

^语法
UnsafeBlockExpression :
unsafe BlockExpression

有关何时使用 unsafe 的更多信息，请参阅 unsafe 块.

代码块可以用 unsafe 关键字作为前缀，以允许不安全操作。示例：

#![allow(unused)]
fn main() {
unsafe {
    let b = [13u8, 17u8];
    let a = &b[0] as *const u8;
    assert_eq!(*a, 13);
    assert_eq!(*a.offset(1), 17);
}

unsafe fn an_unsafe_fn() -> i32 { 10 }
let a = unsafe { an_unsafe_fn() };
}

带标签的块表达式

带标签的块表达式记录在循环和其他可中断表达式部分。

块表达式上的属性

内部属性允许直接放在块表达式的左大括号之后，在以下情况下：

函数和方法主体。
循环体（loop、while、while let 和 for）。
用作语句的块表达式。
作为数组表达式、元组表达式、调用表达式和元组风格结构体表达式的元素的块表达式。
作为另一个块表达式的尾部表达式的块表达式。

在块表达式上具有意义的属性是 cfg 和 lint 检查属性。

例如，此函数在 unix 平台上返回 true，在其他平台上返回 false。

#![allow(unused)]
fn main() {
fn is_unix_platform() -> bool {
    #[cfg(unix)] { true }
    #[cfg(not(unix))] { false }
}
}

Rust 参考手册

块表达式

`async` 块

捕获模式

Async 上下文

控制流运算符

`const` 块

`unsafe` 块

带标签的块表达式

块表达式上的属性