捕获

闭包本质上很灵活，能做功能要求的事情，使闭包在没有类型标注的情况下运行。这使得捕获（capture）能够灵活地适应用例，既可移动（move），又可借用（borrow）。闭包可以通过以下方式捕获变量：

  • 通过引用：&T
  • 通过可变引用：&mut T
  • 通过值：T

闭包优先通过引用来捕获变量，并且仅在需要时使用其他方式。

  1. fn main() {
  2.     use std::mem;
  4.     let color = String::from("green");
  6.     // 这个闭包打印 `color`。它会立即借用（通过引用，`&`）`color` 并将该借用和
  7.     // 闭包本身存储到 `print` 变量中。`color` 会一直保持被借用状态直到
  8.     // `print` 离开作用域。
  9.     //
  10.     // `println!` 只需传引用就能使用，而这个闭包捕获的也是变量的引用，因此无需
  11.     // 进一步处理就可以使用 `println!`。
  12.     let print = || println!("`color`: {}", color);
  14.     // 使用借用来调用闭包 `color`。
  15.     print();
  17.     // `color` 可再次被不可变借用，因为闭包只持有一个指向 `color` 的不可变引用。
  18.     let _reborrow = &color;
  19.     print();
  21.     // 在最后使用 `print` 之后，移动或重新借用都是允许的。
  22.     let _color_moved = color;
  24.     let mut count = 0;
  25.     // 这个闭包使 `count` 值增加。要做到这点，它需要得到 `&mut count` 或者
  26.     // `count` 本身，但 `&mut count` 的要求没那么严格，所以我们采取这种方式。
  27.     // 该闭包立即借用 `count`。
  28.     //
  29.     // `inc` 前面需要加上 `mut`，因为闭包里存储着一个 `&mut` 变量。调用闭包时，
  30.     // 该变量的变化就意味着闭包内部发生了变化。因此闭包需要是可变的。
  31.     let mut inc = || {
  32.         count += 1;
  33.         println!("`count`: {}", count);
  34.     };
  36.     // 使用可变借用调用闭包
  37.     inc();
  39.     // 因为之后调用闭包，所以仍然可变借用 `count`
  40.     // 试图重新借用将导致错误
  41.     // let _reborrow = &count;
  42.     // ^ 试一试：将此行注释去掉。
  43.     inc();
  45.     // 闭包不再借用 `&mut count`，因此可以正确地重新借用
  46.     let _count_reborrowed = &mut count;
  48.     // 不可复制类型（non-copy type）。
  49.     let movable = Box::new(3);
  51.     // `mem::drop` 要求 `T` 类型本身，所以闭包将会捕获变量的值。这种情况下，
  52.     // 可复制类型将会复制给闭包，从而原始值不受影响。不可复制类型必须移动
  53.     // （move）到闭包中，因而 `movable` 变量在这里立即移动到了闭包中。
  54.     let consume = || {
  55.         println!("`movable`: {:?}", movable);
  56.         mem::drop(movable);
  57.     };
  59.     // `consume` 消耗了该变量，所以该闭包只能调用一次。
  60.     consume();
  61.     //consume();
  62.     // ^ 试一试：将此行注释去掉。
  63. }

在竖线 | 之前使用 move 会强制闭包取得被捕获变量的所有权：

  1. fn main() {
  2.     // `Vec` 在语义上是不可复制的。
  3.     let haystack = vec![1, 2, 3];
  5.     let contains = move |needle| haystack.contains(needle);
  7.     println!("{}", contains(&1));
  8.     println!("{}", contains(&4));
  10.     //println!("There're {} elements in vec", haystack.len());
  11.     // ^ 取消上面一行的注释将导致编译时错误，因为借用检查不允许在变量被移动走
  12.     // 之后继续使用它。
  14.     // 在闭包的签名中删除 `move` 会导致闭包以不可变方式借用 `haystack`，因此之后
  15.     // `haystack` 仍然可用，取消上面的注释也不会导致错误。
  16. }

参见：

Box 和 std::mem::drop