Rust 编程语言融合了多种编程法(programming paradigm),以命令式编程(imperative programming)为主,支持函数式编程(functional programming),不必明确定义出函数名称的「闭包」和 for 循环所使用的「迭代器」即是衍生自函数式编程的特性。
在开始介绍闭包之前,我们可以先看一下这个代码:
fn hello_something(something: &str) -> String {
let mut s = String::from("Hello ");
s.push_str(something);
s.push_str("!");
s
}
fn main() {
let h = hello_something;
println!("{}", h("world"));
}
以上程序,第 11 行将 hello_something 函数指派给变量 h 保存,接着在第 13 行直接使用 h 作为函数来调用。这个是合法的语法,可以成功编译,程序运行结果如下:
我们可以将任意的函数或是方法使用变量或是参数保存,将其作为「函数指针」(function pointer)来使用。当然,变量和参数一定会需要有个类型才有办法分配内存空间,那么函数或方法是属于什么类型呢?以上面这个例子来说,h 变量的类型为 fn(&str) -> String,函数或是方法的类型语法就和定义它们的语法一样,且该类型都会实作 Fn、FnMut 和 FnOnce 特性。
此外,函数也可以被定义在某个程序区块内来使用。举例来说:
fn main() {
fn hello_something(something: &str) -> String {
let mut s = String::from("Hello ");
s.push_str(something);
s.push_str("!");
s
}
let h: fn(&str) -> String = hello_something;
println!("{}", h("world"));
}
但是,被定义在程序区块内的函数无法直接使用其所在的 scope 的资源。举例来说:
fn main() {
let hello = "Hello ";
fn hello_something(something: &str) -> String {
let mut s = String::from(hello);
s.push_str(something);
s.push_str("!");
s
}
let h: fn(&str) -> String = hello_something;
println!("{}", h("world"));
}
以上程序会编译失败,因为我们不能够在 main 函数里的 hello_something 函数中,使用 main 函数里的 hello 变量。
接着来谈谈闭包吧!闭包和函数非常相似,但它不像函数一样有着具体的类型(concrete type),不必定义出函数名称,也不必明确定义出参数的类型。闭包甚至还可以在主体内使用其所在的 scope 的资源。
举例来说:
let y = 10;
let plus_one = |x| x + y + 1;
println!("{}", plus_one(2)); // 2 + 10 + 1 = 13
以上程序,我们实作出一个能够计算 x + y + 1 的闭包,并指派给 plus_one 变量保存,我们虽然无法具体的定义 plus_one 变量的类型是什么,但可以确定的是它的类型必定有实作 Fn、FnMut 或 FnOnce 特性。也就是说,我们依然可以透过使用泛型来传递闭包。
整理一下,闭包与函数不同的地方有以下几点:
|| 语法来定义,且参数和回传值类型可以被推论,不需要明确定义出来。2. 当闭包的主体只有一行叙述时,且闭包没有明确定义回传值类型,则程序区块可以省略大括号
{}。3. 闭包主体的程序叙述可以使用其所在的 scope 的资源。
4. 闭包没有具体的类型。
这里比较需要注意到的是第 3 点,在闭包主体内使用其所在的 scope 的资源,实际上会去「借用」该资源。因此以下这个程序会因为 num 变量已经借给 plus_num 变量所指的闭包使用,且这个闭包之后还会被调用,而无法再使用可变参考。如以下程序会编译错误:
let mut num = 5;
let plus_num = |x: i32| x + num;
let y = &mut num;
println!("{}", plus_num(1));
如果该资源会直接被闭包回传,其行为和「将变量指派给另一个变量」一样,会先尝试「拷贝」,如果不行就进行「移动」。如以下程序会编译错误:
let mut v = vec![2];
let c = || v;
println!("{v:?}");
闭包可以与 move 关键字搭配使用,可以强制将其主体内所使用到的其所在的 scope 的资源先尝试「拷贝」,如果不行就进行「移动」,而非原先的借用。因此,以下程序可以编译成功:
let mut num = 5;
let plus_num = move |x: i32| x + num;
let y = &mut num;
println!("{}", plus_num(1));
而以下程序会编译失败:
let mut s = String::from("Hello!");
let c = move || s.len();
println!("{s}");
因为 String 结构体并没有实作 Copy 特性,所以变量 s 会被移动给闭包来使用。
接着来谈谈 Fn、FnMut 和 FnOnce 特性。
Fn 特性
当闭包并没有使用到其所在的 scope 的资源,或是只使用到其所在的 scope 的不可变资源时,且这个闭包可以被调用多次,就会实作这个特性。举例来说:
fn call_with_one<F>(func: F) -> usize
where
F: Fn(usize) -> usize,
{
func(1)
}
fn main() {
let double = |x| x * 2;
println!("{}", call_with_one(double));
}
double 变量所保存的闭包并没有使用到其所在的 scope 的资源,因此它会实作 Fn 特性。这里要注意到以上程序第 3 行,我们在指定泛型要实作的 Fn 特性时,也要去指定其闭包参数和回传值的类型,是比较特别的用法,而 FnMut、FnOnce 特性的泛型使用方式也是跟 Fn 特性一样。
FnMut 特性
当闭包有使用到其所在的 scope 的可变资源时,且这个闭包可以被调用多次,就会实作这个特性。举例来说:
fn do_twice<F>(mut func: F)
where
F: FnMut(),
{
func();
func();
}
fn main() {
let mut x: usize = 1;
let y: usize = 2;
{
let add_two_to_x = || x += y;
do_twice(add_two_to_x);
}
println!("{x}");
}
Fn 特性是 FnMut 特性的子特性,多了资源不可变的限制。
FnOnce 特性
只能被调用一次的闭包只会实作这个特性。举例来说:
fn say_hello<F>(func: F)
where
F: FnOnce() -> String,
{
println!("Hello {}.", func());
}
fn main() {
let word = String::from("world");
let get_word = || word;
say_hello(get_word);
}
get_word 变量所保存的闭包,直接将 word 变量保存的 String 结构实体回传出去,拥有权会发生变化,因此这个闭包在被调用过一次之后就不能再被调用第二次了。
整理一下,FnOnce 特性是所有闭包都会实作的特性,当闭包只能够被调用一次,就只会实作 FnOnce 特性;FnMut 特性继承(inheritance)自 FnOnce 特性,当闭包有使用到其所在的 scope 的可变资源时,就会实作这个特性;Fn 特性继承自 FnMut 特性,当闭包并没有使用到任何其所在的 scope 的资源,或是只使用到其所在的 scope 的不可变资源时就会实作这个特性。
也就是说,如果我们让泛型类型明确定义为有实作 Fn 特性的闭包时,其只允许有实作 Fn 的闭包;如果我们让泛型类型明确定义为有实作 FnMut 特性的闭包时,其也允许有实作 Fn 的闭包;如果我们让泛型类型明确定义为有实作 FnOnce 特性的闭包时,则有实作 Fn、FnMut 和 FnOnce 的闭包都允许。利用这个观念,我们可以对要传递的闭包进行一些特别的筛选。
我们也可以使用 Fn、FnMut 或 FnOnce 特性的参考类型来传递闭包。如下:
fn call_with_one(some_closure: &dyn Fn(i32) -> i32) -> i32 {
some_closure(1)
}
fn main() {
let answer = call_with_one(&|x| x + 2);
println!("{answer}");
}
以上的 dyn 关键字,是在撰写特性的参考类型时要加入的关键字,之后的章节会详细介绍这部份。
一般的函数和方法都会去实作 Fn、FnMut 和 FnOnce 特性,所以也可以像闭包这样被变量或参数保存以及传递。如下:
fn call_with_one(some_closure: &dyn Fn(i32) -> i32) -> i32 {
some_closure(1)
}
fn add_one(i: i32) -> i32 {
i + 1
}
fn main(){
let f = add_one;
let answer = call_with_one(&f);
println!("{answer}");
}
需要传入闭包作为参数的函数,其闭包的参数或回传值的生命周期,可以基于函数本身,而非函数的调用者。如下:
fn call_with_ref<'a, F>(mut some_closure: F, value: &'a mut i32)
where
F: for<'b> FnMut(&'b mut i32),
{
let mut step = 0;
some_closure(&mut step);
*value += step;
}
fn main() {
let some_closure = |x: &mut i32| *x += 2;
let mut value = 4;
call_with_ref(some_closure, &mut value);
println!("{value}");
}
注意以上程序第 3 行,使用了 for 关键字来定义泛型类型的生命周期参数,而非使用其所在函数的泛型参数。如此一来就可以套用函数内 scope 的生命周期,而非调用这个函数的调用者所在的 scope 的生命周期。
迭代器
运用迭代器可以依照顺序对数组或集合进行一些处理,由迭代器负责决定走访元素的顺序以及该次迭代回传结果的时机。Rust 编程语言的标准函数库所提供的最基本的迭代器会依照元素在数据结构中的保存顺序,走访每个元素,并在每次迭代结束时回传该次走访到的元素。
举例来说:
fn main() {
let v1 = [1, 2, 3, 4, 5];
let v1_iter = v1.iter();
for val in v1_iter {
println!("Got: {val}");
}
}
以上程序运行结果为:
Got: 2
Got: 3
Got: 4
Got: 5
善用迭代器可以省下很多撰写重复代码的时间,Rust 编程语言的标准函数库提供了多种常用的迭代器相关功能。例如若要筛选出以上程序,数组所保存的偶数元素,可以利用迭代器提供的 filter 方法,并搭配闭包使用,产生新的迭代器,使其只会回传符合某些条件的元素。程序改写如下:
fn main() {
let v1 = [1, 2, 3, 4, 5];
let v1_iter = v1.iter();
for val in v1_iter.filter(|x| *x % 2 == 0) {
println!("Got: {val}");
}
}
以上程序运行结果为:
Got: 4
也可以使用 map 方法,并搭配闭包使用,产生新的迭代器,使旧的迭代器在迭代的同时能够透过闭包对元素进行一些改变,再交由新的迭代器回传。例如将以上程序改成,取得数组内所保存的偶数元素,并将它们通通乘 2。程序改写如下:
fn main() {
let v1 = [1, 2, 3, 4, 5];
let v1_iter = v1.iter();
for val in v1_iter.filter(|x| *x % 2 == 0).map(|x| x * 2) {
println!("Got: {val}");
}
}
以上程序运行结果为:
Got: 8
如果不想要一次走访所有元素,就不需要使用 for 循环,可以使用迭代器提供的 next 方法,来进行一次迭代,并回传 Option 枚举实体,如果该次迭代有可回传的元素,就会用 Some 变体将元素包裹起来回传;如果没有了,则会回传 None 变体。举例来说:
fn main() {
let v1 = [1, 2, 3];
let mut v1_iter = v1.iter();
println!("Got: {:?}", v1_iter.next());
println!("Got: {:?}", v1_iter.next());
println!("Got: {:?}", v1_iter.next());
println!("Got: {:?}", v1_iter.next());
}
注意此处的 v1_iter 变量必须使用 mut 关键字,因为在使用迭代器的 next 方法时,其当下所指的元素位置会有变化。
以上程序运行结果为:
Got: Some(2)
Got: Some(3)
Got: None
迭代器除了能够让我们自行处理每次迭代的逻辑外,也有提供一些方便的方法能直接在方法内完成走访,来达成某个目的。例如 sum 这个方法,可以快速地将数组或是集合内的元素做加总。举例来说:
fn main() {
let v1 = [1, 2, 3];
let v1_iter = v1.iter();
let total: i32 = v1_iter.sum();
println!("{total}");
}
利用迭代器提供的 sum 方法,来快速完成数组中所有元素的加总。以上程序运行结果为:
我们先前使用过的 collect 方法,也是跟 sum 方法一样,会直接在方法内完成数组或是集合的走访,直接回传新的集合。
我们也可以自行实作出迭代器,只需要让结构体去实作 Iterator 特性,完成 Iterator 特性的 next 函数即可。举例来说:
struct Color {
r: u8,
g: u8,
b: u8,
}
struct ColorIterator<'a> {
color: &'a Color,
index: usize,
}
impl<'a> Iterator for ColorIterator<'a> {
type Item = u8;
fn next(&mut self) -> Option<u8> {
let result = match self.index {
0 => self.color.r,
1 => self.color.g,
2 => self.color.b,
_ => return None,
};
self.index += 1;
Some(result)
}
}
impl Color {
fn new(r: u8, g: u8, b: u8) -> Color {
Color { r, g, b }
}
fn iter(&self) -> ColorIterator {
ColorIterator { color: self, index: 0 }
}
}
fn main() {
let color = Color::new(0, 128, 255);
for v in color.iter() {
println!("{v}");
}
}
以上程序,实作了一个 ColorIterator 结构体作为 Color 结构体的迭代器,能够依照 r、g、b 的顺序来走访 Color 结构体的字段。这边要注意到的是程序第 13 行的部份,实作 Iterator 特性的时候,必须使用 type 关键字来指定 Item 的类型,这个 Item 为 Iterator 特性的关联类型(Associated Type),代表每次迭代时要被包裹在 Option 枚举的 Some 变体回传的元素类型。关联类型的详细用法会在之后的章节介绍。
另外还有 IntoIterator 特性,可以用来替结构体实作其在遇到 for 循环的时候要如何取得迭代器来使用。通常 IntoIterator 特性会实作在结构体的不可变参考类型和可变参考类型上,而不会实作在结构体本身。像是数组的参考类型有实作 IntoIterator 特性,因此假设要用 for 循环走访一个数组,可以使用 for e in &array 这样的写法。而 Vec 结构体本身也有实作 IntoIterator 特性,因此假设要用 for 循环走访一个 Vec 结构实体,可以使用 for e in vec 这样的写法,但是这会发生「变量指派给另一个变量」的行为,而导致 vec 变量被「移动」了,故通常还是会使用参考类型作为进入迭代器的方式。
将以上程序的 Color 结构体的不可变参考,加上 IntoIterator 特性后,程序如下:
struct Color {
r: u8,
g: u8,
b: u8,
}
struct ColorIterator<'a> {
color: &'a Color,
index: usize,
}
impl<'a> Iterator for ColorIterator<'a> {
type Item = u8;
fn next(&mut self) -> Option<u8> {
let result = match self.index {
0 => self.color.r,
1 => self.color.g,
2 => self.color.b,
_ => return None,
};
self.index += 1;
Some(result)
}
}
impl Color {
fn new(r: u8, g: u8, b: u8) -> Color {
Color { r, g, b }
}
fn iter(&self) -> ColorIterator {
ColorIterator { color: self, index: 0 }
}
}
impl<'a> IntoIterator for &'a Color {
type Item = u8;
type IntoIter = ColorIterator<'a>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
fn main() {
let color = Color::new(0, 128, 255);
for v in &color {
println!("{v}");
}
}
改写 grep 程序
我们来用闭包和迭代器来改写上一章节完成的 grep 程序吧!
use std::env;
use std::process;
use minigrep::*;
fn main() {
let args: Vec<String> = env::args().collect();
let config = Config::new(&args).unwrap_or_else(|err| {
eprintln!("Problem parsing arguments: {err}");
process::exit(1);
});
if let Err(e) = minigrep::run(config) {
eprintln!("Application error: {e}");
process::exit(1);
}
}
use std::env;
use std::error::Error;
use std::fs::File;
use std::io::prelude::*;
pub struct Config {
pub query: String,
pub filepath: String,
pub case_sensitive: bool,
}
impl Config {
pub fn new(args: &[String]) -> Result<Config, &str> {
if args.len() < 3 {
return Err("not enough arguments");
}
let query = args[1].clone();
let filepath = args[2].clone();
let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
Ok(Config { query, filepath, case_sensitive })
}
}
fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
fn search_case_insensitive<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = open_read_file(&config.filepath);
for line in if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
} {
println!("{line}");
}
Ok(())
}
fn open_read_file(filepath: &str) -> String {
let mut f = File::open(filepath).expect("file not found");
let mut contents = String::new();
f.read_to_string(&mut contents).expect("something went wrong reading the file");
contents
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn one_result() {
let query = "duct";
let contents = "Rust:\nsafe, fast, productive.\nPick three.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "Rust:\nsafe, fast, productive.\nPick three.\nTrust me.";
assert_eq!(vec!["Rust:", "Trust me."], search_case_insensitive(query, contents));
}
}
在我们原先的 grep 程序,lib.rs 文件的第 18 行和第 19 行使用了字符串的 clone 方法来拷贝字符串。原则上,如非必要,应尽量地避免使用 clone 方法拷贝相同的数据。拷贝内存中的数据不但会需要花费时间进行,还会在内存中耗用不同的空间去保存相同的东西,赔了夫人又折兵。我们之所以在这边使用 clone 方法来拷贝字符串,是因为我们无法直接将某数据结构字段的数据之拥有权交给其它变量保存。
为了要解决这个问题,我们必须改良读取透过命令行传进来的参数的方式。原先在 main.rs 文件的第 7 行,我们取得命令行参数的迭代器后,直接使用 collect 方法将其走访完,并产生 Vec 结构实体。如今的我们,已经学会了迭代器的用法,要想办法善用迭代器的特性来读取数据。
首先,我们需要修改 Config 结构体的 new 关联函数,使它可以透过参数传入命令行参数的迭代器,接着就可以利用该迭代器的 next 方法来逐一读取参数了!next 方法只能用在可变的数据上,因此在定义 new 关联函数的参数时,必须加上 mut 关键字。
修改后的程序如下:
use std::env;
use std::process;
use minigrep::*;
fn main() {
let config = Config::new(env::args()).unwrap_or_else(|err| {
eprintln!("Problem parsing arguments: {err}");
process::exit(1);
});
if let Err(e) = minigrep::run(config) {
eprintln!("Application error: {e}");
process::exit(1);
}
}
use std::env;
use std::env::Args;
use std::error::Error;
use std::fs::File;
use std::io::prelude::*;
pub struct Config {
pub query: String,
pub filepath: String,
pub case_sensitive: bool,
}
impl Config {
pub fn new(mut args: Args) -> Result<Config, &'static str> {
args.next();
let query = match args.next() {
Some(arg) => arg,
None => return Err("Didn't get a query string"),
};
let filepath = match args.next() {
Some(arg) => arg,
None => return Err("Didn't get a file path"),
};
let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
Ok(Config { query, filepath, case_sensitive })
}
}
fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let mut results = Vec::new();
for line in contents.lines() {
if line.contains(query) {
results.push(line);
}
}
results
}
fn search_case_insensitive<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let query = query.to_lowercase();
let mut results = Vec::new();
for line in contents.lines() {
if line.to_lowercase().contains(&query) {
results.push(line);
}
}
results
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = open_read_file(&config.filepath);
for line in if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
} {
println!("{line}");
}
Ok(())
}
fn open_read_file(filepath: &str) -> String {
let mut f = File::open(filepath).expect("file not found");
let mut contents = String::new();
f.read_to_string(&mut contents).expect("something went wrong reading the file");
contents
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn one_result() {
let query = "duct";
let contents = "Rust:\nsafe, fast, productive.\nPick three.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "Rust:\nsafe, fast, productive.\nPick three.\nTrust me.";
assert_eq!(vec!["Rust:", "Trust me."], search_case_insensitive(query, contents));
}
}
lib.rs 文件的部份有个地方要注意的是,原先我们并没有对 Config 结构体的 new 关联函数的回传值,也就是 Result 枚举的泛型参数值 &str 设置生命周期,那是因为当时函数的泛型生命周期参数显然是可以被编译器推论的(只有一个参考类型的参数)。而此时因为 new 关联函数没有参考类型的参数了,&str 的生命周期就无法被自动推论,但我们知道这个 &str 就是我们写在代码内的字符串定数,因此它的生命周期就是 'static。
修改过的 grep 程序,已经解决了在内存无谓地拷贝相同数据的问题。但它还是有个我们可以明显改进的地方,那就是 for 循环和 if 关键字的连用,可以用迭代器的 filter 方法和闭包来处理。Vec 结构体的部份也可以直接用迭代器的 collect 方法来产生。将所有被找出来的该行印出的部份也可以使用迭代器的 for_each 方法来完成。
于是我们可以再将 lib.rs 修改如下:
use std::env;
use std::env::Args;
use std::error::Error;
use std::fs::File;
use std::io::prelude::*;
pub struct Config {
pub query: String,
pub filepath: String,
pub case_sensitive: bool,
}
impl Config {
pub fn new(mut args: Args) -> Result<Config, &'static str> {
args.next();
let query = match args.next() {
Some(arg) => arg,
None => return Err("Didn't get a query string"),
};
let filepath = match args.next() {
Some(arg) => arg,
None => return Err("Didn't get a file path"),
};
let case_sensitive = env::var("CASE_INSENSITIVE").is_err();
Ok(Config { query, filepath, case_sensitive })
}
}
fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
contents.lines().filter(|line| line.contains(query)).collect()
}
fn search_case_insensitive<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
let query = query.to_lowercase();
contents.lines().filter(|line| line.to_lowercase().contains(&query)).collect()
}
pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
let contents = open_read_file(&config.filepath);
let results = if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
};
results.iter().for_each(|line| {
println!("{line}");
});
Ok(())
}
fn open_read_file(filepath: &str) -> String {
let mut f = File::open(filepath).expect("file not found");
let mut contents = String::new();
f.read_to_string(&mut contents).expect("something went wrong reading the file");
contents
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn one_result() {
let query = "duct";
let contents = "Rust:\nsafe, fast, productive.\nPick three.";
assert_eq!(vec!["safe, fast, productive."], search(query, contents));
}
#[test]
fn case_insensitive() {
let query = "rUsT";
let contents = "Rust:\nsafe, fast, productive.\nPick three.\nTrust me.";
assert_eq!(vec!["Rust:", "Trust me."], search_case_insensitive(query, contents));
}
}
在大多数的情况下,迭代器都拥有比循环更好的性能以及可读性,应多加利用。
结论
受到函数式编程的启发,闭包和迭代器已是 Rust 编程语言的一大特色,可以增加代码的利用率,不会占用程序运行阶段的运算资源,还可以增进程式的性能。下一个章节,我们会深入学习 Cargo 和 crates.io 的用法。
下一章:Cargo 和 Crates.io。
