学习一门底层语言，犹如修炼内功，帮助我们以更底层的视角看待编程，写出健壮安全的代码。修炼 Rust 绝非一朝一夕，本系列文章旨在从 JavaScript 开发者的角度，对比和厘清 Rust 中那些有趣的，难啃的，或独有的概念，帮助同胞们迈出学习 Rust 的第一步。完整文章传送门： [写给前端开发者的 Rust 入门指南 Part 1 - 内存](https://juejin.cn/post/7154560939298127879) [写给前端开发者的 Rust 入门指南 Part 2 - 所有权](https://juejin.cn/post/7157184478178181151) [写给前端开发者的 Rust 入门指南 Part 3 - 借用](https://juejin.cn/post/7159195626415079460) [写给前端开发者的 Rust 入门指南 Part 4 - 生命周期](https://juejin.cn/post/7166516328235270175) 📍当前位置水会枯竭，火会燃尽，人会衰朽，世间万物都有其寿命。在 Rust 世界里，有的值生在栈上（Stack），有的值活在堆里（Heap），有的值被拥有（所有权），有的值被出借（借用）。这一切的活动的背后，都受一只无形大手的影响 --「生命周期」。我认为，「生命周期」是入门 Rust 时最令人不解的东西。一来，这是 Rust 独有的，其他语言不存在的新概念，无从参考；再者，理解「生命周期」需要站在编译器的角度思考问题，脑回路不那么直接。我在开始接触「生命周期」时，最困惑的不是怎么用，而是到底为什么要有这个东西？没有这东西不可以吗？所以，有必要详细探究一下 -- 为什么要有生命周期？ ## 为什么要生命周期所谓生命周期，就是一个值从创建到销毁的整个过程。虽说每个值都有其生命周期，但我们在编码的时候却不必时刻在意。因为大多数场景下，值的生死存亡是自动的：对 JS 来说，有垃圾回收机制来替我们操心；在 Rust 里，所有权机制保障变量离开作用域的时候值被销毁。那为什么要专门撰文讲述「生命周期」呢？回答这个问题，我们要回顾一下**借用机制**的核心原则： > **「一个借用（引用），不能活得比出借者（引用的值）长」** 以上这句话是 Rust 的铁律，一个绝对不能违背的**钢铁原则**。Rust 的借用检查机制（Borrow Checking）会时时刻刻确保这个原则被遵守 -- 通过追踪值的「生命周期」： ![lifetime-viz.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c6899ad5e32643c3bc72589f78e20bf0~tplv-k3u1fbpfcp-watermark.image?) ### 生命周期的表示以上代码，Rust 编译器会默默给作用域内的每个值标注生命周期，过程大概是这样：变量 v 的生命周期就叫做 `'a` 吧, 变量 x 的生命周期就叫做 `'b`。由于 `’a` 的「活动范围」明显大于 `'b`，也就是说，v（引用）比 x（引用的值）活得长（v outlive x），这会导致 v 在 x 死亡后，指向一个错误的值。违反了我们的「钢铁原则」，万万不行🙅，报错。注意，字母 a，b 不是重点，只是随便选两个字母，代表两个不同的生命周期。a，b 前面的单引号 `'` 在 Rust 中读「tick」，专门用来标注生命周期。所以这两个生命周期读起来是「tick a」，「tick b」。很有意思，tick 是秒针跳动的声音，用来指代生命周期很生动。tick、tick、tick...感受到值的生命在慢慢流逝了么。不错，把生命周期读出来，就是理解的第一步。 ### 站在人类的角度借用检查在**一个作用域内**，运行良好。但如果碰到这个情况👇： ```rust fn smaller(m: &i32, n: &i32) -> &i32 { if m <= n { m } else { n } } ``` smaller 函数接收两个**整数的引用**作为参数，返回较小的那一个。这个函数的入参和返回值**都是引用**。函数逻辑看上去一目了然，然而，如果你尝试调用它，编译器却无情地抛出错误： ```rust error[E0106]: missing lifetime specifier --> src/any.rs:1:35 | 1 | fn smaller(m: &i32, n: &i32) -> &i32 { | ---- ---- ^ expected named lifetime parameter | = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `m` or `n` help: consider introducing a named lifetime parameter | 1 | fn smaller<'a>(m: &'a i32, n: &'a i32) -> &'a i32 { | ++++ ++ ++ ++ For more information about this error, try `rustc --explain E0106`. ``` Rust 的报错信息就像学霸的笔记，不但告诉你出错了，还会告诉你错在哪里，甚至教你怎么修复。我们来逐句分析：首先，Rust 告诉我们，主要问题是「missing lifetime specifier」，翻译过来就是「缺失生命周期标识」。接着在两个参数和返回值下面做了标记，意思是这三个地方，需要**显式地标记出生命周期参数**（expected named lifetime parameter）。紧接着通过 help 信息告诉我们它（编译器）的疑惑： > help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `m` or `n` > > 咦？这个函数的返回值是一个借用。但是从函数的声明，我无法确定到底借用的是 m 还是 n。这里要展开讲讲。编译器在编译时，最小单位是**函数**。Rust 在编译这个函数的时候，它所知的一切信息，都在这个函数声明里了，包括入参，返回值，函数体内的逻辑。它并不知道今后这个函数在调用的时候，到底会面临什么样的情况。具体到这个例子，编译器只知道参数 m 和 n 是 i32 整数类型的引用，最终返回其中一个引用，到底会返回哪一个？只有函数调用的当下才知道, 无奈编译器管不到运行时, 但它内心时刻惦记着：**「一个借用（引用），不能活得比出借者（引用的值）长」**，所以凡是遇到入参和返回值都是引用（借用）的情况，它会特别担心，此刻，它最怕发生的事情是：函数在调用的时候，返回值活得比参数 m，n 长。比如这个情况： ```rust fn main() { let v1 = vec![4,5,6]; let res; { let v2 = vec![1,2,3]; res = smaller(&v1[0], &v2[0]); } println!("The smaller one is {:?}",res); } ``` 我们用肉眼和人脑来分析一下这个情况：smaller 传入动态数组 v1 和 v2 的第一个元素**的引用**（&i32 类型）。一眼可以看出 v1 和 v2的生命周期是不同的，v1 的生命周期贯穿了整个 main 函数，而 v2 的生命周期只在花括号内的短短两行代码之内，花括号一结束（`}`），v2 就不存在了。所以 v1 的生命长于（outlive）v2。smaller 函数内部返回了 v1 和 v2 中元素的引用（m 或 n），可以看出这个情况返回的是参数 n（1<4），也就是 v2 中元素的引用 -- `&v2[0]`，返回值被赋值给了花括号之外的变量 res，**变量 res 的生命周期也贯穿了整个 main 函数，比 v2 活得长**。意识到大问题了么？请一起吟唱借用的「**钢铁原则**」： > **「一个借用（引用），不能活得比出借者（引用的值）长」** 动态数组 v2 的引用 -- `&v2[0]`, 也就是函数的返回值，活得竟然比 v2 还长。花括号一结束，v2 销毁，res（也就是`&v2[0]`）就变成了迷途指针（Dangling Pointer），找不到回家的路。万万不可🙅。 ### 站在编译器的角度作为人类，只有把 smaller 函数放在具体的调用环境下分析，才能看出其中的风险。但在编译的时候，编译器干巴巴盯着 smaller 函数，是没有这些调用的上下文的，况且 smaller 函数可能在任何地方，任何情况下调用。编译器如何保证参数 m，n 和返回值（3个引用类型），在调用的时候是安全的呢？不会违背「一个借用（引用），不能活得比出借者（引用的值）长」的原则呢？它**办不到**，于是寻求我们的帮助，要我们为它标注生命周期，告诉它参数和返回值之间的关系。请继续看上文中的报错信息： ```rust help: consider introducing a named lifetime parameter | 1 | fn smaller<'a>(m: &'a i32, n: &'a i32) -> &'a i32 { | ++++ ++ ++ ++ ``` 编译器建议我们手动给 smaller 函数标注生命周期，而且贴心地给我们标注好了！感动！我们来详细看看：smaller 后面尖括号里的 `<'a>`, 意思是声明了一个生命周期参数 `'a`，如果你熟悉 TypeScript 的话，会知道函数后尖括号里边定义的是「范型参数」，Rust 也一样，但除了可以在尖括号里声明范型参数，还可以声明生命周期参数（Lifetime Parameter）。申明好了就可以用了，接着把生命周期 `'a` 加在了参数 m，n 以及函数返回值的前面，紧挨着引用符号`&`后边，变成 `&'a`。整体要表达的意思是：smaller 函数有这么一个生命周期 `'a`, 其参数 m，n 至少活得有 `'a` 这么长，且返回值也不能活得超过 `'a`，也就意味着，返回值不能比参数 m，n 活得长，最多也就一样长，都是 `'a` 这么长。目前为止，就这么多信息，有点抽象对不对。 `'a` 叫做「生命周期参数」，参数之所以是参数，是因为只有在调用时，根据传入的值，才能真正确定下来。生命周期参数在函数定义的时候，仅仅描述了函数的入参之间，入参和返回值之间的「相对关系」。现在，smaller 函数有了生命周期标记 `'a` , 再回到这个例子，来看看 Rust 编译器是怎么通过生命周期标记来保证引用安全的： ```rust // 带着生命周期标注的 smaller fn smaller<'a>(m: &'a i32, n: &'a i32) -> &'a i32 { if m <= n { m } else { n } } fn main() { let v1 = vec![4,5,6]; let res; { let v2 = vec![1,2,3]; res = smaller(&v1[0], &v2[0]); } println!("The smaller one is {:?}",res); } ``` 前面我们用肉眼和人脑分析出这段代码存在危险。现在我们用编译器的思考方式再来看看：smaller 函数传入 v1 和 v2 中元素的引用，通过生命周期标注可知，这两个参数的生命周期都是 `'a`，但 v1 和 v2 的生命周期明明不一样啊？？v1 活得比 v2 长啊🤔。这时候，聪明的编译器会取**较小的**那个生命周期，也就是 v2 的生命周期，赋给生命周期参数 `'a`。为什么取较小的那个？因为编译器的目标是保证引用不能活得比引用的值长。就这个例子来说，返回值不能活得比参数长（因为返回值借用了其中一个参数）。想想看，一个引用，如果连较小的那个生命周期都活不过，就一定活不过较大的那个生命周期，说明就安全了。所以，smaller 的生命周期参数 `'a` 就是变量 v2 的生命周期，也等同于 v2 所在的花括号内的生命周期。别忘了，smaller 函数的返回值也标记了 `'a` ，意味着，返回值的生命周期也是 v2 的生命周期，也就是 v2 所在花括号内的生命周期，换句话说，**返回值不能活得超过花括号**。可是，代码中，返回值却赋值给了变量 res，变量 res 的生命周期明显比花括号长，万万不可🙅，报错。再梳理一下编译器的思考链路：因为： > 条件1：'a = v2 的生命周期 > > 条件2：'a = 返回值的生命周期可得出👇 > 结论1：返回值的生命周期 = v2 的生命周期（或者说返回值生命周期不超过 v2 的生命周期）又可知 > 条件3: v2 的生命周期等于 v2 所在花括号的生命周期可得出👇 > 结论2：返回值不能活得超过 v2 所在花括号编译器的思考逻辑是数学的，逻辑的，和人脑的有所不同，但殊途同归。想要通过编译，只需要稍微改变一下调用的情况： ```rust // 以下代码可以成功编译✅ fn smaller<'a>(m: &'a i32, n: &'a i32) -> &'a i32 {...} fn main() { let v1 = vec![1,2,3]; { let v2 = vec![4,5,6]; let res = smaller(&v1[0], &v2[0]); println!("The smaller one is {:?}",res); } } ``` 改变后的代码，变量 res 和变量 v2 的生命周期是一样的，都是花括号包裹的范围，所以 smaller 的返回值不会超过 v2 的生命周期，符合 smaller 的生命周期标注。编译通过✅。以上就是编译器作为机器的思考过程，编译器不是人脑，如果没有给 smaller 函数标注生命周期，编译器就无法确定参数 m，n 和返回值之间生命周期的「相对关系」，也就无法在函数调用的上下文执行**借用检查**（Borrow Checking），自然无法保证「一个借用（引用），不能活得比出借者（引用的值）长」的原则了。所以，编译器在某些情况下需要生命周期标注的帮助。值得注意的是，「生命周期标注」只是「标注」，是编码者给编译器提供信息，帮助它在编译阶段顺利执行借用检查，这些标注**不会**影响和改变函数的入参和返回值的真实的生命周期。编译器总是默默奉献，劳苦功高，竟然也有需要我们帮助的时候，简直是人机合作的典范了，不要吝啬，用标注报答它吧。总结一下： - 生命周期标注是为了保证引用的安全，我们只会给引用（借用）标注生命周期 - 定义函数时，给入参和返回值标注生命周期，是定义它们之间生命周期的相对关系 - 在函数调用的上下文，根据传入的实参才可确定生命周期参数的值，如果违反了预先定义好的相对关系，编译失败 - 生命周期标注只是标注，不改变数据的真实生命周期 ## 函数的生命周期给函数标注生命周期参数是最常见的场景，有多种情况： ### 没有参数直接返回引用一个函数直接返回一个引用，是最明显的引用错误： ```rust fn hello<'a>() -> &'a str { let s= String::from("hello"); &s // error: cannot return reference to local variable `s` } ``` 函数 hello 在没有任何入参的情况下，返回了一个引用。在 Rust 中这意味着：返回的引用肯定来自于**函数内部**的某个变量，也就是内部变量 s，变量 s 在函数调用结束后就销毁了，一定会导致返回的引用 &s 指向错误的内存地址。编译器看到这种没有入参，却返回一个引用的情况，会直接报错🙅。小贴士：对于 JavaScript 开发者来说，这里可能存在疑惑：为什么函数直接返回引用肯定来自于**函数内部**的某个变量？在 JS 中函数可以访问到定义时所在作用域的任何变量，不一定要是函数内部啊🤔： ```javascript let s = "hello"; function hello() { return s // 访问到外部变量 s } hello() // 返回 "hello" ``` 是的，Rust 的函数**不可以访问函数以外的数据**。难道 Rust 没有闭包功能吗？不是的，闭包是 Rust 的杀手锏，只不过 Rust 闭包需要专门的召唤方式，这是另一个话题了。 ### 返回的引用和参数无关同理，如果函数传入的参数和返回的引用无关，也会造成引用错误： ```rust fn smaller<'a>(m: &'a i32, n: &'a i32) -> &'a i32 { let number = 100; &number // error: cannot return reference to local variable `number` } ``` 这个 smaller 函数有模有样地标注了参数和返回值的生命周期，实际上入参和返回值没有任何关系，而是直接返回了内部变量 number 的引用，这本质上和上一种情况没有区别，会造成引用错误，Rust 坚决反对这种挂羊头卖狗肉的行为🙅。 ### 多个不同的生命周期上文中，我们给 smaller 函数的两个参数标注了同一个生命周期 `'a`, 在调用的上下文，`'a`会取传入的实参中生命周期较小的那个。如果需要，也可以声明多个不同的生命周期参数： ```rust fn smaller<'a, 'b>(m: &'a i32, n: &'b i32) -> &'a i32 {...} ``` 声明多个不同的生命周期参数，只需要把多个生命周期参数在尖括号里用逗号隔开。我们分别把生命周期 `’a` 和 `’b` 标注给了参数 m 和 n。意图表达，m 和 n 有两个不同的生命周期。很遗憾，这段代码无法通过编译： ```rust 1 | fn smaller<'a, 'b>(m: &'a i32, n: &'b i32) -> &'a i32 { | ------- ------- | | | this parameter and the return type are declared with different lifetimes... ... 5 | n | ^ ...but data from `n` is returned here ``` 编译器一眼就看出了问题，m 和 n 有不同的生命周期，但是返回值却随意地标注了其中一个（`'a`）, 但明明 m 和 n 都有可能被返回啊，如果返回的是另一个，生命周期不就错乱了吗？这里要给返回值标注什么呢？我们说过，生命周期标注描述的是入参之间，入参和返回值之间的「相对关系」，我们这里想要表达的核心诉求是 --**返回值（引用）不能活得超过入参（引用的值）**。由于返回值来自于入参，那就要求返回值的生命周期要**小等于**所有的入参的生命周期，这等价于：返回值的生命周期要小等于**所有参数生命周期中最小的那一个**。所以要想知道返回值的引用如何标注，就要知道 `'a` 和 `'b` 哪一个的生命周期比较小，这个信息我们需要「喂给」编译器： ### 生命周期约束 ```rust // 编译通过✅ fn smaller<'a: 'b, 'b>(m: &'a i32, n: &'b i32) -> &'b i32 {...} ``` 请注意尖括号里的语法 -- `'a: 'b`。意思是：生命周期 `'a` 比生命周期 `'b` 活得长，不妨直接把中间的 `:` 号理解成 `>` 号。这叫生命周期约束语法，用来指定生命周期参数的长短关系。我们用**较短**的生命周期 `'b` 标注了函数的返回值。意思是：函数的返回值要小等于入参的生命周期中较小的那一个，任务完成，编译通过✅。在这个场景中，m 和 n 标注成 `'a` 和 `'b` 或者`'b` 和 `'a` 无关紧要，也不会影响调用时候的检查，对于编译器来说，有效信息有两个： 1. `'b` 和 `'a` 是两个不同的生命周期，`'b` 是较短的那一个 2. 返回值**不能**活得超过`'b` 和 `'a` 中较小的那一个，也就是`'b` 晕了晕了，一开始全部标注成 `'a` 就没这么多事，怎么想标注清楚这么难啊！请不要气馁，对此你只要心中有数即可，最佳应对策略是：**永远先尝试简单的标注，不行了再说，兜兜转转也总会标注好的。** ### 部分参数生命周期标注如果函数返回值只和其中部分引用类型的参数有关，可以只标注部分参数的生命周期： ```rust fn add_string<'a>(m: &'a mut String, n: &str) -> &'a String { m.push_str(n); m } ``` 函数 add_string 接受两个参数：m 的类型是 `&mut String` -- 字符串的可变借用；n 的类型是 &str -- 字符串字面量。这个函数功能是给第一个参数 m 拼接上第二个参数 n，最终返回拼接后的字符串引用。可以看见，函数内部修改了可变借用 m 并把它返回，我们可以认为返回值只和参数 m 有关，所以只需要标注了 m 和返回值的生命周期。 ### 静态生命周期上述例子中，参数 n 是字符串字面量（String Literal），在 Rust 中，`let s = "hello"` 这样声明的字符串，就叫字符串字面量。字符串字面量在编译之后会打包到程序包的可执行文件里去（比如 exe 文件），在程序初始化的时候加载到内存中，直到程序关闭才销毁，也就是说字符串字面量的生命周期和整个程序一样长。程序初始化时，把字符串字面量存到某个内存地址，这个地址就和这个字符串绑定了，在程序结束之前都不会变，这个字符串拥有固定的，静态的内存地址。我们可以说，字符串字面量拥有**静态生命周期**。总结来说，拥有静态生命周期的数据，有固定的内存地址，活得和整个程序一样长。 > *小帖士:字符串字面量的类型是 `&str`。之所以是一个引用，是因为字符串（str）本身是无法直接访问的，只能通过一个引用访问这个字符串的固定地址，所以类型是 &str。* 再看看 add_string 函数，没有标注生命周期的参数 n 就是一个字符串字面量，具备静态生命周期，我们也可以显示标注 n 的生命周期（虽然毫无必要）👇： ```rust fn add_string<'a>(m: &'a mut String, n: &‘static str) -> &'a String ``` `'static` 标注表示数据具有静态的生命周期。使用 `'static` 的时候不用提前在尖括号里面声明，直接标注就好。在这个例子中，因为 add_string 函数的返回值和 n 没有关系, 这样标注**毫无意义**。我们换一个场景： ```rust // 以下代码无法编译通过🙅 fn foo(n: &'static i32) { ... } let v = 88; foo(&v); ``` foo 函数的参数 n 是一个具有静态生命周期的 i32 整数类型，但是传入的实参 &v 在离开作用域之后就销毁了，明显不是静态生命周期，所以编译不通过。 ```javascript // 以下代码可以编译通过✅ fn foo(n: &'static i32) { ... } static V: i32 = 88; // 用 static 声明静态变量 foo(&V); ``` 如果想要通过编译，就需要保证传入的整数引用具备静态生命周期。通过 static 关键字声明的变量叫做静态变量，具备静态的生命周期。静态变量可以理解成全局变量，在程序运行的整个过程都可以访问到。所以传入静态变量引用 &V（静态变量大写是 Rust 的风格），可以通过编译。值得注意的是，虽然 static 关键字声明的变量具备静态生命周期，但静态生命周期的变量不一定出自 static 声明，比如字符串字面量不需要 static 声明，就拥有静态生命周期。拥有静态生命周期的数据活得和整个程序一样长，仅仅指**数据本身**。**不是和数据绑定的变量**，变量在离开作用域的时候依然会被销毁： ```rust { let s = "Hello Rust"; println!("{}", s); // s 离开作用域被销毁 } // 变量 s 没有了，但 "Hello Rust" 这几个字符串依然存在内存中，直到程序终结 ``` ## 结构体的生命周期目前为止，生命周期标注一直围绕着函数。其实结构体也常常需要标注生命周期。设想一个结构体内部的字段，引用了其他数据： ```rust // 以下代码无法通过编译🙅 struct Point { x: &i32, y: &i32 } ``` 结构体 Point 内部的 x,y 属性是引用类型，也就是说这个结构体引用了外部的其他数据，不知道你有没有嗅到危险的气息：如果引用的数据都不在了，比如 x 引用的数据已经被销毁了，结构体还活着，继续访问 x 就会出错。所以，Rust 力图保证： > 「结构体不能活得超过其内部引用的值」所以，当结构体内部有引用数据，也需要标注生命周期： ```rust // 编译通过✅ struct Point<'a> { x: &'a i32, y: &'a i32 } ``` 这个标注告诉编译器：结构体 Point 的实例不能活得超过其 x，y 引用的数据，最多一起活 `'a` 这么长。如果： ```rust struct Point<'a> { x: &'a i32, y: &'a i32 } fn main() { let p; { let x = 10; let y = 10; p = Point {x: &x, y: &y}; // x，y 销毁，但实例 p 还活着 } println!("{}", p.x) // 访问出错 } ``` 变量 x，y 离开花括号作用域就销毁了，但实例 p 还活着，万万不可🙅。结构体的标注原理和函数是一样的，可以举一反三： ```rust // 标注不同的生命周期及限定语法 struct Point<'a: 'b, 'b> { x: &'a i32, y: &'b i32 } // 标注部分生命周期 struct Point<'a> { x: &'a i32, y: &'a i32, z: i32 } // 标注静态生命周期 struct Point { x: &'static i32, y: &'static i32 } ``` 函数和结构体的生命周期标注是最常见的情形，但不限于此二者。本文目标是阐明生命周期的核心概念，掌握了核心，表象种种也自然可以见招拆招了。 ## 生命周期标注省略规则虽然生命周期标注可以帮助 Rust 理解我们的代码，但也并**不需要**时时刻刻，勤勤恳恳地标注每一个函数。事实上，Rust 编译器在某些情况下会自动「推断」生命周期，换句话说，Rust 编译器有一套生命周期省略规则（Lifetime Elision Rule）： ### 规则1：只有一个引用类型入参的情况如果函数的参数只有一个引用，且返回一个引用。Rust 会推断**返回值**和**参数**的生命周期是一样的。 ```rust fn first(v: &Vec) -> &i32 { &v[0] } ``` 函数 first 接受一个动态数组的引用作为参数，返回该数组第一项的引用。这种情况下我们不需要标注任何声明周期，因为 Rust 会自动推断出生命周期为👇： ```rust fn first<'a>(v: &'a Vec) -> &'a i32 { &v[0] } ``` 这非常合情合理。如果一个函数接收一个引用，返回一个引用，那么这个返回值肯定是来自于参数，它们具有相同的生命周期。这种情况下我们可以省略生命周期标注。如果一个函数有多个参数，但只有其中一个是引用，同样可以省略👇： ```rust fn first(v: &Vec, n: bool) -> &i32 {...} ``` 可以看到，参数 n 是布尔类型，不是引用，所以返回的引用肯定来自参数 v，依然可以省略标注。 ### 规则2：多个引用类型入参的情况如果函数有多个引用类型的参数，但懒懒的你并没有标注生命周期。Rust 会默认每一个需要标注的参数，都有不一样的生命周期。 ```rust fn foo(s1: &str, s2: &str) -> &str {...} ``` 函数 foo 的参数 s1, s2 都是引用类型，返回的也是引用类型。这种情况，如果不标注生命周期，Rust 会先推断 s1, s2 拥有两个**不同的**生命周期： ```rust fn foo<'a, 'b>(s1: &'a str, s2: &'b str) -> &str {...} ``` 两个参数推断出了生命周期，那返回值 `&str` 呢？对不起，编译器在此时无能为力了，因为没有任何其他信息可以辅助它做出返回值生命周期的推断，所以以上代码无法通过编译。你可能充满疑惑🤔，那这条规则有什么用？请接着往下看👇： ### 规则3：参数中有 &self 或者 &mut self 的情况这里出现了一个新的概念 `self`，可以理解成 JavaScript 中的 `this`。用 JavaScript 举一个例子吧： ```javascript class Square { constructor(length) { this.length = length; } area() { return this.length * this.length } } let s = new Square(10); s.area() // 100 ``` 一目了然。Square 是一个代表正方形的类。构造函数中传入边长 length。方法 area 用来计算正方形的面积。这个逻辑，如果用 Rust 表达👇： ```rust // 定义 Square 结构体 struct Square { length: i32, } // 为 Square 实现一个 area 方法 impl Square { fn area(&self) -> i32 { self.length * self.length } } fn main() { let s = Square { length: 10 }; // 实例化结构体 let area = s.area(); // 调用实例上的方法 println!("{:?}", area) } ``` 在这个例子中，`struct Square` 可以类比 JS 的 `class Square`。通过`impl` 关键词为结构体实现方法，`impl` 是 implement 的简写，「实现，履行」之意。方法 area 接受的参数是 `&self`, self 可以类比 JS 中的 `this`，指代结构体 Square 的**实例**。前面加一个 `&` 变成 `&self`, 意思是结构体**实例的引用**，`&mut self`就是结构体**实例的可变引用**。假如不是引用，调用方法就会传入结构体实例本身，这个例子中，如果不是传入 `&self`，而是 self，变量 s 在调用 area 方法后，就会失去所有权，后续不可以访问了，会造成诸多不便，所以开发中 `&self` 比 `self` 多见。介绍了什么是 self，回到正题。「生命周期标注省略规则」约定，如果参数中有 `&self` 或者 `&mut self`，则返回值的生命周期会推断为`&self` ，`&mut self` 的生命周期，也就是**实例的生命周期**👇 ```rust struct Square<'a> { length: i32, desc: &'a str } // 为 Square 实现一个 area 方法 impl<'a> Square<'a> { fn area ... fn info(&self, other: &str) -> &str { println!("{}", other); self.desc } } ``` 我们为 Square 增加了一个引用类型的属性 desc，结构体存在引用需要标注生命周期，所以标注了 `'a`。接着我们为 Square 定义了一个 info 方法：参数类型是 &self 和 &str，返回类型是 &str。这个情况首先命中了规则 2：当存在多个引用参数的时候，每个引用参数都有不同的生命周期；接着命中规则 3：如果输入引用中有 &self，&mut self, 返回值的生命周期会推断为 `&self`，`&mut self` 的生命周期。如果我们不标注，Rust 会推断标注为👇： ```javascript // 返回值的生命周期和 self 的生命周期标注为 'x fn info<'x, 'y>(&'x self, other: &'y str) -> &'x str // 内心OS：好丑的代码呀，花里胡哨的，还好可以省略😮‍💨 ``` 仔细琢磨一下，一个结构体的方法引用了结构体实例，返回一个引用，这个返回值肯定引用了结构体的实例。由于**引用不能活得超过引用的值**，所以 Rust 推断返回值和传入实例的生命周期相同，非常合理。另外需要注意 `impl<'a> Square<'a>` 这行代码。当我们为具备生命周期标注的结构体实现方法时，需要先在 impl 后面用尖括号声明生命周期，并「传递」到结构体的尖括号里面。好在方法定义大多数情况不需要标注生命周期（命中规则2，3），不然代码可读性真是灾难。 ## 总结洋洋洒洒说这么多，如果你记不住或无法理解，请至少记住： 1. 生命周期标注是为了帮助编译器判断引用的生命周期，避免迷途指针（Dangling Pointer） 2. 一个策略：正常写代码，当编译器提示需要生命周期标注时，再考虑标注 ## 结语回到最开始的问题： > 为什么要有**生命周期**呢？ > 因为有借用。 > > 为什么要有**借用**呢？ > 因为值有**所有权**。 > > 为什么要有所有权呢？ > 为了保障内存安全。 > > 如何保障**内存安全**呢？ > 保证堆内存上的数据用完及时销毁，指针不会迷路。顺着问题一路反推，最终抵达 Rust 的初心 -- 「**内存安全**」。由此出发，Rust 构建了一套独一无二的编码范式，发明了一些无处参考崭新概念，既令人心存敬畏，又不禁心潮澎湃。如果你看到这里，你已经攀爬上了 Rust 入门最险峻的山峰，回头看看走过的路吧，然后继续上路，还有更高的山峰等待着你。