if let

在一些场合下，用 match 匹配枚举类型并不优雅。比如：

  1. // 将 `optional` 定为 `Option<i32>` 类型
  2. let optional = Some(7);
  4. match optional {
  5.     Some(i) => {
  6.         println!("This is a really long string and `{:?}`", i);
  7.         // ^ 行首需要 2 层缩进。这里从 optional 中解构出 `i`。
  8.         // 译注：正确的缩进是好的，但并不是 “不缩进就不能运行” 这个意思。
  9.     },
  10.     _ => {},
  11.     // ^ 必须有，因为 `match` 需要覆盖全部情况。不觉得这行很多余吗？
  12. };

if let 在这样的场合要简洁得多，并且允许指明数种失败情形下的选项：

  1. fn main() {
  2.     // 全部都是 `Option<i32>` 类型
  3.     let number = Some(7);
  4.     let letter: Option<i32> = None;
  5.     let emoticon: Option<i32> = None;
  7.     // `if let` 结构读作：若 `let` 将 `number` 解构成 `Some(i)`，则执行
  8.     // 语句块（`{}`）
  9.     if let Some(i) = number {
  10.         println!("Matched {:?}!", i);
  11.     }
  13.     // 如果要指明失败情形，就使用 else：
  14.     if let Some(i) = letter {
  15.         println!("Matched {:?}!", i);
  16.     } else {
  17.         // 解构失败。切换到失败情形。
  18.         println!("Didn't match a number. Let's go with a letter!");
  19.     };
  21.     // 提供另一种失败情况下的条件。
  22.     let i_like_letters = false;
  24.     if let Some(i) = emoticon {
  25.         println!("Matched {:?}!", i);
  26.     // 解构失败。使用 `else if` 来判断是否满足上面提供的条件。
  27.     } else if i_like_letters {
  28.         println!("Didn't match a number. Let's go with a letter!");
  29.     } else {
  30.         // 条件的值为 false。于是以下是默认的分支：
  31.         println!("I don't like letters. Let's go with an emoticon :)!");
  32.     };
  33. }

同样，可以用 if let 匹配任何枚举值：

  1. // 以这个 enum 类型为例
  2. enum Foo {
  3.     Bar,
  4.     Baz,
  5.     Qux(u32)
  6. }
  8. fn main() {
  9.     // 创建变量
  10.     let a = Foo::Bar;
  11.     let b = Foo::Baz;
  12.     let c = Foo::Qux(100);
  14.     // 变量 a 匹配到了 Foo::Bar
  15.     if let Foo::Bar = a {
  16.         println!("a is foobar");
  17.     }
  19.     // 变量 b 没有匹配到 Foo::Bar，因此什么也不会打印。
  20.     if let Foo::Bar = b {
  21.         println!("b is foobar");
  22.     }
  24.     // 变量 c 匹配到了 Foo::Qux，它带有一个值，就和上面例子中的 Some() 类似。
  25.     if let Foo::Qux(value) = c {
  26.         println!("c is {}", value);
  27.     }
  28. }

另一个好处是：if let 允许匹配枚举非参数化的变量，即枚举未注明 #[derive(PartialEq)]，我们也没有为其实现 PartialEq。在这种情况下，通常 if Foo::Bar==a 会出错，因为此类枚举的实例不具有可比性。但是，if let 是可行的。

你想挑战一下吗？使用 if let修复以下示例：

  1. // 该枚举故意未注明 `#[derive(PartialEq)]`，
  2. // 并且也没为其实现 `PartialEq`。这就是为什么下面比较 `Foo::Bar==a` 会失败的原因。
  3. enum Foo {Bar}
  5. fn main() {
  6.     let a = Foo::Bar;
  8.     // 变量匹配 Foo::Bar
  9.     if Foo::Bar == a {
  10.     // ^-- 这就是编译时发现的错误。使用 `if let` 来替换它。
  11.         println!("a is foobar");
  12.     }
  13. }

参见：

枚举，Option，和相关的 RFC