01-解构 on 编程那些事儿

01-元组

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/flow_control/match/destructuring/destructure_tuple.html

元组

元组可以在 match 中解构，如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


fn main() {
 let triple = (0, -2, 3);
 // 试一试 ^ 将不同的值赋给 `triple`

 println!("Tell me about {:?}", triple);
 // match 可以解构一个元组
 match triple {
 // 解构出第二个和第三个元素
 (0, y, z) => println!("First is `0`, `y` is {:?}, and `z` is {:?}", y, z),
 (1, ..) => println!("First is `1` and the rest doesn't matter"),
 // `..` 可用来忽略元组的其余部分
 _ => println!("It doesn't matter what they are"),
 // `_` 表示不将值绑定到变量
 }
}
//Tell me about (0, -2, 3)
//First is `0`, `y` is -2, and `z` is 3

参见：

元组

02-数组/切片

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/flow_control/match/destructuring/destructure_slice.html

数组/切片

像元组一样，数组和切片也可以这样解构:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


fn main() {
 // 尝试改变数组中的值，或者将其做成切片!
 let array = [1, -2, 6];

 match array {
 // 将第二个和第三个元素绑定到各自的变量
 [0, second, third] =>
 println!("array[0] = 0, array[1] = {}, array[2] = {}", second, third),

 // 单个值可以用 `_` 忽略
 [1, _, third] => println!(
 "array[0] = 1, array[2] = {} and array[1] was ignored",
 third
 ),

 // 你也可以绑定一些而忽略其余的
 [-1, second, ..] => println!(
 "array[0] = -1, array[1] = {} and all the other ones were ignored",
 second
 ),
 // 下面的代码无法编译
 // [-1, second] => ...

 // 或者将它们存储在另一个数组/切片中（类型取决于所匹配的值的类型）
 [3, second, tail @ ..] => println!(
 "array[0] = 3, array[1] = {} and the other elements were {:?}",
 second, tail
 ),

 // 结合这些模式，我们可以绑定第一个和最后一个值，并将其余的值存储在一个数组中
 [first, middle @ .., last] => println!(
 "array[0] = {}, middle = {:?}, array[2] = {}",
 first, middle, last
 ),
 }
}
//array[0] = 1, array[2] = 6 and array[1] was ignored

参见：

数组和切片与 @ 符号用法绑定

03-枚举

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/flow_control/match/destructuring/destructure_enum.html

枚举

和前面相似，解构 enum 的方式如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


// 需要 `allow` 来消除警告，因为只使用了枚举类型的一种取值。
#[allow(dead_code)]
enum Color {
 // 这三个取值仅由它们的名字（而非类型）来指定。
 Red,
 Blue,
 Green,
 // 这些则把 `u32` 元组赋予不同的名字，以色彩模型命名。
 RGB(u32, u32, u32),
 HSV(u32, u32, u32),
 HSL(u32, u32, u32),
 CMY(u32, u32, u32),
 CMYK(u32, u32, u32, u32),
}

fn main() {
 let color = Color::RGB(122, 17, 40);
 // 试一试 ^ 将不同的值赋给 `color`

 println!("What color is it?");
 // 可以使用 `match` 来解构 `enum`。
 match color {
 Color::Red => println!("The color is Red!"),
 Color::Blue => println!("The color is Blue!"),
 Color::Green => println!("The color is Green!"),
 Color::RGB(r, g, b) =>
 println!("Red: {}, green: {}, and blue: {}!", r, g, b),
 Color::HSV(h, s, v) =>
 println!("Hue: {}, saturation: {}, value: {}!", h, s, v),
 Color::HSL(h, s, l) =>
 println!("Hue: {}, saturation: {}, lightness: {}!", h, s, l),
 Color::CMY(c, m, y) =>
 println!("Cyan: {}, magenta: {}, yellow: {}!", c, m, y),
 Color::CMYK(c, m, y, k) =>
 println!("Cyan: {}, magenta: {}, yellow: {}, key (black): {}!",
 c, m, y, k),
 // 不需要其它分支，因为所有的情形都已覆盖
 }
}
//What color is it?
//Red: 122, green: 17, and blue: 40!

参见：

#[allow(...)], 色彩模型和 enum

04-指针和引用

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/flow_control/match/destructuring/destructure_pointers.html

指针和引用

对指针来说，解构（destructure）和解引用（dereference）要区分开，因为这两者的概念是不同的，和 C 那样的语言用法不一样。

05-结构体

Thu, 20 Aug 2026 21:20:00 +0800

译文 · 基于 Rust By Example

原文链接: https://doc.rust-lang.org/stable/rust-by-example/flow_control/match/destructuring/destructure_structures.html

结构体

类似地，解构 struct 如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


fn main() {
 struct Foo { x: (u32, u32), y: u32 }

 // 解构结构体的成员
 let foo = Foo { x: (1, 2), y: 3 };
 let Foo { x: (a, b), y } = foo;

 println!("a = {}, b = {}, y = {} ", a, b, y);//a = 1, b = 2, y = 3 

 // 可以解构结构体并重命名变量，成员顺序并不重要

 let Foo { y: i, x: j } = foo;
 println!("i = {:?}, j = {:?}", i, j);//i = 3, j = (1, 2)

 // 也可以忽略某些变量
 let Foo { y, .. } = foo;
 println!("y = {}", y);//y = 3

 // 这将得到一个错误：模式中没有提及 `x` 字段
 // let Foo { y } = foo;
}

参见：

结构体, ref 模式