Rust 的闭包由一个匿名函数加上外层的作用域组成,举个例子:
fn main() { let closure = |n: u32| -> u32 { n * 2 }; println!("n * 2 = {}", closure(12)); // n * 2 = 24 }
闭包可以被保存在一个变量中,然后我们注意一下它的语法,参数定义、返回值定义都和普通函数一样,但闭包使用的是两个竖线。我们对比一下两者的区别:
// 普通函数定义 fn func1(a: u32, b: u32) -> String { // 函数体 } /* 如果换成闭包的话,那么等价于 let func1 = |a: u32, b: u32| -> String { // 函数体 } */
所以两者在语法上没有什么本质的区别,但这个时候可能有人好奇了,我们能不能把闭包中的匿名函数换成普通函数呢?来试一下。
fn main() { let closure1 = |n: u32| -> u32 { n * 2 }; fn closure2(n: u32) -> u32 { n * 2 } println!("n * 2 = {}", closure1(12)); println!("n * 2 = {}", closure2(12)); /* n * 2 = 24 n * 2 = 24 */ }
从表面上来看是可以的,但其实还存在问题,因为 closure2 只是一个在函数里定义的函数而已。而闭包除了要包含函数之外,还要包含函数所在的外层作用域,什么意思呢?我们举例说明:
你看到了什么?没错,在函数 closure2 内部无法使用外层作用域中的变量 a,因此它只是定义在 main 函数里的函数而已,而不是闭包,因为它不包含外层函数(main)的作用域。
而 Rust 提示我们使用 || { ... },那么 closure1 显然是闭包,因为它除了包含一个函数(匿名),还包含了外层作用域,我们将这个闭包赋值给了 closure1。
此外闭包还有一个重要的用途,就是在多线程编程时,可以将主线程的变量移动到子线程内部。
关于多线程后续会详细说,这里只是举个例子。
// 导入线程模块 use std::thread; fn main() { let s = String::from("hello world"); // 必须在 || 的前面加上 move // 它的含义就是将值从主线程移动到子线程 let closure1 = move || { println!("{}", s); }; // 开启一个子线程 thread::spawn(closure1).join(); /* hello world */ }
打印是发生在主线程当中的,而不是子线程,以上就是闭包相关的内容。
了解完闭包之后,再来看看高阶函数,在数学和计算机中,高阶函数是至少满足下列一个条件的函数:
在数学中它们也叫算子或者泛函,高阶函数是函数式编程中非常重要的一个概念。
先来看看如何定义一个接收函数作为参数的函数:
// calc 接收三个参数,返回一个 i32 // 参数一:接收两个 i32 返回一个 i32 的函数 // 参数二 和 参数三均是一个 i32 fn calc(method: fn(i32, i32) -> i32, a: i32, b: i32) -> i32 { method(a, b) } fn add(a: i32, b: i32) -> i32 { a + b } fn main() { println!("a + b = {}", calc(add, 12, 33)); /* a + b = 45 */ // 也可以传递一个匿名函数,但它不能引用外层作用域的变量 // 因为 calc 第一个参数接收的是函数,不是闭包 let sub = |a: i32, b: i32| -> i32 { a - b }; println!("a - b = {}", calc(sub, 12, 33)); /* a - b = -21 */ }
以函数作为参数,在类型声明中我们不需要写函数名以及参数名,只需要指明参数类型、数量和返回值类型即可。
然后再观察一下函数 calc 的定义,由于第一个参数 method 接收一个函数,所以它的定义特别的长,我们能不能简化一下呢?
// 相当于给类型起了一个别名 type Method = fn(i32, i32) -> i32; fn calc(method: Method, a: i32, b: i32) -> i32 { method(a, b) }
这种做法也是可以的。
看完了接收函数作为参数,再来看看如何将函数作为返回值。
type Method = fn(i32, i32) -> i32; // 想要接收字符串的话 // 应该使用引用 &String 或切片 &str // 当然我们前面说过,更推荐切片 fn calc(op: &str) -> Method { fn add(a: i32, b: i32) -> i32 { a + b } let sub = |a: i32, b: i32| -> i32 { a - b }; // 使用 if else 也是可以的 match op { "add" => add, "sub" => sub, // 内置的宏,会抛出一个错误,表示方法没有实现 _ => unimplemented!(), } // 注意:此处不可以加分号,因为要作为表达式返回 } fn main() { let (a, b) = (11, 33); println!("a + b = {}", calc("add")(a, b)); println!("a - b = {}", calc("sub")(a, b)); /* a + b = 44 a - b = -22 */ }
以上就是高阶函数,还是很好理解的,和 Python 比较类似。你可以基于这个特性,实现一个装饰器,只是 Rust 里面没有 @ 这个语法糖罢了。这里我们简单地实现一下吧,加深一遍印象。
enum Result { Text(String), Func(fn() -> String), } fn index() -> String { String::from("欢迎来到古明地觉的编程教室") } fn login_required(username: &str, password: &str) -> Result { if !(username == "satori" && password == "123") { return Result::Text(String::from("请先登录")); } else { return Result::Func(index); } } fn main() { let res1 = login_required("xxx", "yyy"); let res2 = login_required("satori", "123"); // 如果后续还要使用 res1 和 res2,那么就使用引用 // 也就是 [&res1, &res2] // 但这里我们不用了,所以是 [res1, res2],此时会转移所有权 for item in [res1, res2] { match item { Result::Text(error) => println!("{}", error), Result::Func(index) => println!("{}", index()), } } /* 请先登录 欢迎来到古明地觉的编程教室 */ }
是不是很有趣呢?这里再次看到了枚举类型的威力,我们有可能返回字符串,也有可能返回函数,那么应该怎么办呢?很简单,将它们放到枚举里面即可,这样它们都是枚举类型。至于到底是哪一个成员,再基于 match 分别处理即可。
还记得 match 吗?match 可以有任意多个分支,每一个分支都应该返回相同的类型,并且只有一个分支会执行成功,然后该分支的返回值会作为整个 match 表达式的返回值。
最后再来看看发散函数,这个概念在其它语言里面应该很少听到。在 Rust 里面,发散函数永远不会返回,它的返回值被标记为 !,表示这是一个空类型。
// 发散函数的返回值类型是一个感叹号 // 它表示这个函数执行时会报错 fn foo() -> ! { panic!("这个函数执行时会报错") } fn main() { // 调用发散函数时,可以将其结果赋值给任意类型的变量 let res1: u32 = foo(); let res2: f64 = foo(); }
所以这个发散函数没啥卵用,你在实际开发中估计一辈子也用不上,因为它在执行的时候会 panic 掉。所以这段代码编译的时候是没有问题的,但执行时会触发 panic。既然执行时会报错,那么当然可以赋值给任意类型的变量。
因此当返回值类型为 ! 时,我们需要通过 panic 宏让函数在执行的过程中报错。但要注意的是,发散函数和不指定返回值的函数是不一样的,举个例子:
// 发散函数的返回值类型是一个感叹号 // 它表示这个函数执行时会报错 fn foo() -> ! { panic!("这个函数执行时会报错"); } // 不指定返回值,默认返回 () // 所以以下等价于 fn bar() -> () {} // 但很明显 bar 函数是有返回值的,会返回空元组 fn bar() { }
总的来说发散函数没啥卵用,在工作中也不建议使用,只要知道有这么个东西就行。