闭包是一个可捕获周围环境的可执行代码片段,基本的几个定义方式如下:
fn add_one_v1 (x: u32) -> u32 { x + 1 }
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x| { x + 1 };
let add_one_v4 = |x| x + 1 ;
| |
内部的是捕获的周围的变量,默认捕获的是不可变借用,先给出一个实际代码片段:
use std::thread;
use std::time::Duration;
fn main() {
let foo = |num| { // 定义一个闭包,捕获一个变量
thread::sleep(Duration::from_millis(num));
println!("sleep for {} milliseconds", num);
};
let num = 200;
foo(num);
}
注意:闭包一般不必显式声明变量的类型,但是闭包只能推断一种类型的数据,再次出现其它类型的数据时会报错。 给出代码说明:
fn main() {
let foo = |x| x;
foo(1.1);
foo("foo".to_string()); // 这里会报错,第一次推断的时候,就已经明确这是f32的类型看了
}
如果我们想让闭包在第一次调用时就保存好结果,之后返回第一次计算的结果,可以使用缓存的机制,下面代码给出一般的缓存机制。但是,这个机制存在一个问题,如果第一次有了计算结果了,那么再次传入新的值,返回的也是第一次计算的结果。
struct Cache<T>
where T: Fn(u32) -> u32 // 注意这里闭包声明的方式
{
calculation: T,
value: Option<u32>
}
impl<T> Cache<T>
where T: Fn(u32) -> u32
{
fn new(calculation: T) -> Cache<T> {
Cache {
calculation,
value: None
}
}
fn value(&mut self, arg: u32) -> u32 {
match self.value {
Some(v) => v,
None => {
let v = (self.calculation)(arg);
self.value = Some(v);
v
},
}
}
}
fn main() {
let mut res = Cache::new(|num| {
num * num
});
let v1 = res.value(2);
let v2 = res.value(10); // 这仍然会返回之前的结果
println!("v1 = {}, v2 = {}", v1, v2); // v1 = 4, v2 = 4
}
如果想要根据不同的值计算结果,可以利用HashMap
等的思路。
闭包三种捕获方式,附带3种声明方式:
FnOnce
消费从周围作用域捕获的变量,闭包周围的作用域被称为其 环境,environment。为了消费捕获到的变量,闭包必须获取其所有权并在定义闭包时将其移动进闭包。其名称的 Once 部分代表了闭包不能多次获取相同变量的所有权的事实,所以它只能被调用一次。FnMut
获取可变的借用值所以可以改变其环境Fn
从其环境获取不可变的借用值