@ -2,7 +2,7 @@
< html lang = "en" >
< head >
< meta charset = "UTF-8" >
< title > 生命周期与引用有效性 - Rust 程序设计语言 简体中文版< / title >
< title > 测试的组织结构 - Rust 程序设计语言 简体中文版< / title >
< meta content = "text/html; charset=utf-8" http-equiv = "Content-Type" >
< meta name = "description" content = "Rust 程序设计语言 简体中文版" >
< meta name = "viewport" content = "width=device-width, initial-scale=1" >
@ -47,7 +47,7 @@
< / script >
< div id = "sidebar" class = "sidebar" >
< ul class = "chapter" > < li > < a href = "ch01-00-introduction.html" > < strong > 1.< / strong > 介绍< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch01-01-installation.html" > < strong > 1.1.< / strong > 安装< / a > < / li > < li > < a href = "ch01-02-hello-world.html" > < strong > 1.2.< / strong > Hello, World!< / a > < / li > < / ul > < / li > < li > < a href = "ch02-00-guessing-game-tutorial.html" > < strong > 2.< / strong > 猜猜看教程< / a > < / li > < li > < a href = "ch03-00-common-programming-concepts.html" > < strong > 3.< / strong > 通用编程概念< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch03-01-variables-and-mutability.html" > < strong > 3.1.< / strong > 变量和可变性< / a > < / li > < li > < a href = "ch03-02-data-types.html" > < strong > 3.2.< / strong > 数据类型< / a > < / li > < li > < a href = "ch03-03-how-functions-work.html" > < strong > 3.3.< / strong > 函数如何工作< / a > < / li > < li > < a href = "ch03-04-comments.html" > < strong > 3.4.< / strong > 注释< / a > < / li > < li > < a href = "ch03-05-control-flow.html" > < strong > 3.5.< / strong > 控制流< / a > < / li > < / ul > < / li > < li > < a href = "ch04-00-understanding-ownership.html" > < strong > 4.< / strong > 认识所有权< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch04-01-what-is-ownership.html" > < strong > 4.1.< / strong > 什么是所有权< / a > < / li > < li > < a href = "ch04-02-references-and-borrowing.html" > < strong > 4.2.< / strong > 引用 & 借用< / a > < / li > < li > < a href = "ch04-03-slices.html" > < strong > 4.3.< / strong > Slices< / a > < / li > < / ul > < / li > < li > < a href = "ch05-00-structs.html" > < strong > 5.< / strong > 结构体< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch05-01-method-syntax.html" > < strong > 5.1.< / strong > 方法语法< / a > < / li > < / ul > < / li > < li > < a href = "ch06-00-enums.html" > < strong > 6.< / strong > 枚举和模式匹配< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch06-01-defining-an-enum.html" > < strong > 6.1.< / strong > 定义枚举< / a > < / li > < li > < a href = "ch06-02-match.html" > < strong > 6.2.< / strong > < code > match< / code > 控制流运算符< / a > < / li > < li > < a href = "ch06-03-if-let.html" > < strong > 6.3.< / strong > < code > if let< / code > 简单控制流< / a > < / li > < / ul > < / li > < li > < a href = "ch07-00-modules.html" > < strong > 7.< / strong > 模块< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch07-01-mod-and-the-filesystem.html" > < strong > 7.1.< / strong > < code > mod< / code > 和文件系统< / a > < / li > < li > < a href = "ch07-02-controlling-visibility-with-pub.html" > < strong > 7.2.< / strong > 使用< code > pub< / code > 控制可见性< / a > < / li > < li > < a href = "ch07-03-importing-names-with-use.html" > < strong > 7.3.< / strong > 使用< code > use< / code > 导入命名< / a > < / li > < / ul > < / li > < li > < a href = "ch08-00-common-collections.html" > < strong > 8.< / strong > 通用集合类型< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch08-01-vectors.html" > < strong > 8.1.< / strong > vector< / a > < / li > < li > < a href = "ch08-02-strings.html" > < strong > 8.2.< / strong > 字符串< / a > < / li > < li > < a href = "ch08-03-hash-maps.html" > < strong > 8.3.< / strong > 哈希 map< / a > < / li > < / ul > < / li > < li > < a href = "ch09-00-error-handling.html" > < strong > 9.< / strong > 错误处理< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch09-01-unrecoverable-errors-with-panic.html" > < strong > 9.1.< / strong > < code > panic!< / code > 与不可恢复的错误< / a > < / li > < li > < a href = "ch09-02-recoverable-errors-with-result.html" > < strong > 9.2.< / strong > < code > Result< / code > 与可恢复的错误< / a > < / li > < li > < a href = "ch09-03-to-panic-or-not-to-panic.html" > < strong > 9.3.< / strong > < code > panic!< / code > 还是不< code > panic!< / code > < / a > < / li > < / ul > < / li > < li > < a href = "ch10-00-generics.html" > < strong > 10.< / strong > 泛型、trait 和生命周期< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch10-01-syntax.html" > < strong > 10.1.< / strong > 泛型数据类型< / a > < / li > < li > < a href = "ch10-02-traits.html" > < strong > 10.2.< / strong > trait： < / a > < / li > < li > < a href = "ch10-03-lifetime-syntax.html" > < strong > 10.3.< / strong > 生命周期与引用有效性< / a > < / li > < / ul > < / li > < / ul >
< ul class = "chapter" > < li > < a href = "ch01-00-introduction.html" > < strong > 1.< / strong > 介绍< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch01-01-installation.html" > < strong > 1.1.< / strong > 安装< / a > < / li > < li > < a href = "ch01-02-hello-world.html" > < strong > 1.2.< / strong > Hello, World!< / a > < / li > < / ul > < / li > < li > < a href = "ch02-00-guessing-game-tutorial.html" > < strong > 2.< / strong > 猜猜看教程< / a > < / li > < li > < a href = "ch03-00-common-programming-concepts.html" > < strong > 3.< / strong > 通用编程概念< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch03-01-variables-and-mutability.html" > < strong > 3.1.< / strong > 变量和可变性< / a > < / li > < li > < a href = "ch03-02-data-types.html" > < strong > 3.2.< / strong > 数据类型< / a > < / li > < li > < a href = "ch03-03-how-functions-work.html" > < strong > 3.3.< / strong > 函数如何工作< / a > < / li > < li > < a href = "ch03-04-comments.html" > < strong > 3.4.< / strong > 注释< / a > < / li > < li > < a href = "ch03-05-control-flow.html" > < strong > 3.5.< / strong > 控制流< / a > < / li > < / ul > < / li > < li > < a href = "ch04-00-understanding-ownership.html" > < strong > 4.< / strong > 认识所有权< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch04-01-what-is-ownership.html" > < strong > 4.1.< / strong > 什么是所有权< / a > < / li > < li > < a href = "ch04-02-references-and-borrowing.html" > < strong > 4.2.< / strong > 引用 & 借用< / a > < / li > < li > < a href = "ch04-03-slices.html" > < strong > 4.3.< / strong > Slices< / a > < / li > < / ul > < / li > < li > < a href = "ch05-00-structs.html" > < strong > 5.< / strong > 结构体< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch05-01-method-syntax.html" > < strong > 5.1.< / strong > 方法语法< / a > < / li > < / ul > < / li > < li > < a href = "ch06-00-enums.html" > < strong > 6.< / strong > 枚举和模式匹配< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch06-01-defining-an-enum.html" > < strong > 6.1.< / strong > 定义枚举< / a > < / li > < li > < a href = "ch06-02-match.html" > < strong > 6.2.< / strong > < code > match< / code > 控制流运算符< / a > < / li > < li > < a href = "ch06-03-if-let.html" > < strong > 6.3.< / strong > < code > if let< / code > 简单控制流< / a > < / li > < / ul > < / li > < li > < a href = "ch07-00-modules.html" > < strong > 7.< / strong > 模块< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch07-01-mod-and-the-filesystem.html" > < strong > 7.1.< / strong > < code > mod< / code > 和文件系统< / a > < / li > < li > < a href = "ch07-02-controlling-visibility-with-pub.html" > < strong > 7.2.< / strong > 使用< code > pub< / code > 控制可见性< / a > < / li > < li > < a href = "ch07-03-importing-names-with-use.html" > < strong > 7.3.< / strong > 使用< code > use< / code > 导入命名< / a > < / li > < / ul > < / li > < li > < a href = "ch08-00-common-collections.html" > < strong > 8.< / strong > 通用集合类型< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch08-01-vectors.html" > < strong > 8.1.< / strong > vector< / a > < / li > < li > < a href = "ch08-02-strings.html" > < strong > 8.2.< / strong > 字符串< / a > < / li > < li > < a href = "ch08-03-hash-maps.html" > < strong > 8.3.< / strong > 哈希 map< / a > < / li > < / ul > < / li > < li > < a href = "ch09-00-error-handling.html" > < strong > 9.< / strong > 错误处理< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch09-01-unrecoverable-errors-with-panic.html" > < strong > 9.1.< / strong > < code > panic!< / code > 与不可恢复的错误< / a > < / li > < li > < a href = "ch09-02-recoverable-errors-with-result.html" > < strong > 9.2.< / strong > < code > Result< / code > 与可恢复的错误< / a > < / li > < li > < a href = "ch09-03-to-panic-or-not-to-panic.html" > < strong > 9.3.< / strong > < code > panic!< / code > 还是不< code > panic!< / code > < / a > < / li > < / ul > < / li > < li > < a href = "ch10-00-generics.html" > < strong > 10.< / strong > 泛型、trait 和生命周期< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch10-01-syntax.html" > < strong > 10.1.< / strong > 泛型数据类型< / a > < / li > < li > < a href = "ch10-02-traits.html" > < strong > 10.2.< / strong > trait： < / a > < / li > < li > < a href = "ch10-03-lifetime-syntax.html" > < strong > 10.3.< / strong > 生命周期与引用有效性< / a > < / li > < / ul > < / li > < li > < a href = "ch11-00-testing.html" > < strong > 11.< / strong > 测试< / a > < / li > < li > < ul class = "section" > < li > < a href = "ch11-01-writing-tests.html" > < strong > 11.1.< / strong > 编写测试< / a > < / li > < li > < a href = "ch11-02-running-tests.html" > < strong > 11.2.< / strong > 运行测试< / a > < / li > < li > < a href = "ch11-03-test-organization.html" > < strong > 11.3.< / strong > 测试的组织结构< / a > < / li > < / ul > < / li > < / ul >
< / div >
< div id = "page-wrapper" class = "page-wrapper" >
@ -5357,6 +5357,270 @@ references in the signature must have the same lifetime, <code>'a</code></p>
< p > 现在函数签名表明对于某些生命周期< code > 'a< / code > ，函数会获取两个参数，他们都是与生命周期< code > 'a< / code > 存在的一样长的字符串 slice。函数会返回一个同样也与生命周期< code > 'a< / code > 存在的一样长的字符串 slice。这就是我们告诉 Rust 需要其保证的协议。< / p >
< p > 通过在函数签名中指定生命周期参数，我们不会改变任何参数或返回值的生命周期，不过我们说过任何不坚持这个协议的类型都将被借用检查器拒绝。这个函数并不知道（或需要知道）< code > x< / code > 和< code > y< / code > 具体会存在多久，不过只需要知道一些可以使用< code > 'a< / code > 替代的作用域将会满足这个签名。< / p >
< p > 当在函数中使用生命周期注解时，这些注解出现在函数签名中，而不存在于函数体中的任何代码中。这是因为 Rust 能够分析函数中代码而不需要任何协助，不过当函数引用或被函数之外的代码引用时，参数或返回值的生命周期可能在每次函数被调用时都不同。这可能会产生惊人的消耗并且对于 Rust 来说经常都是不可能分析的。在这种情况下，我们需要自己标注生命周期。< / p >
< p > 当具体的引用被传递给< code > longest< / code > 时，具体被< code > 'a< / code > 所替代的生命周期是< code > x< / code > 的作用域与< code > y< / code > 的作用域相重叠的那一部分。因为作用域总是嵌套的，所以换一种说法就是泛型生命周期< code > 'a< / code > 的具体生命周期等同于< code > x< / code > 和< code > y< / code > 的生命周期中较小的那一个。因为我们用相同的生命周期参数标注了返回的引用值，所以返回的引用值就能保证在< code > x< / code > 和< code > y< / code > 中较短的那个生命周期结束之前保持有效。< / p >
< p > 让我们如何通过传递拥有不同具体生命周期的引用来观察他们是如何限制< code > longest< / code > 函数的使用的。列表 10-22 是一个应该在任何编程语言中都很直观的例子：< code > string1< / code > 直到外部作用域结束都是有效的，< code > string2< / code > 则在内部作用域中是有效的，而< code > result< / code > 则引用了一些直到外部作用域结束都是有效的值。借用检查器赞同这些代码；它能够编译和运行，并打印出< code > The longest string is long string is long< / code > ： < / p >
< figure >
< span class = "filename" > Filename: src/main.rs< / span >
< pre > < code class = "language-rust" > # fn longest< 'a> (x: & 'a str, y: & 'a str) -> & 'a str {
# if x.len() > y.len() {
# x
# } else {
# y
# }
# }
#
fn main() {
let string1 = String::from(" long string is long" );
{
let string2 = String::from(" xyz" );
let result = longest(string1.as_str(), string2.as_str());
println!(" The longest string is {}" , result);
}
}
< / code > < / pre >
< figcaption >
< p > Listing 10-22: Using the < code > longest< / code > function with references to < code > String< / code > values
that have different concrete lifetimes< / p >
< / figcaption >
< / figure >
< p > 接下来，让我们尝试一个< code > result< / code > 的引用的生命周期必须比两个参数的要短的例子。将< code > result< / code > 变量的声明从内部作用域中移动出来，不过将< code > result< / code > 和< code > string2< / code > 变量的赋值语句一同放在内部作用域里。接下来，我们将使用< code > result< / code > 的< code > println!< / code > 移动到内部作用域之外，就在其结束之后。注意列表 10-23 中的代码不能编译：< / p >
< figure >
< span class = "filename" > Filename: src/main.rs< / span >
< pre > < code class = "language-rust" > # fn longest< 'a> (x: & 'a str, y: & 'a str) -> & 'a str {
# if x.len() > y.len() {
# x
# } else {
# y
# }
# }
#
fn main() {
let string1 = String::from(" long string is long" );
let result;
{
let string2 = String::from(" xyz" );
result = longest(string1.as_str(), string2.as_str());
}
println!(" The longest string is {}" , result);
}
< / code > < / pre >
< figcaption >
< p > Listing 10-23: Attempting to use < code > result< / code > after < code > string2< / code > has gone out of scope
won't compile< / p >
< / figcaption >
< / figure >
< p > 如果尝试编译会出现如下错误：< / p >
< pre > < code > error: `string2` does not live long enough
|
6 | result = longest(string1.as_str(), string2.as_str());
| ------- borrow occurs here
7 | }
| ^ `string2` dropped here while still borrowed
8 | println!(" The longest string is {}" , result);
9 | }
| - borrowed value needs to live until here
< / code > < / pre >
< p > 错误表明为了保证< code > println!< / code > 中的< code > result< / code > 是有效的，< code > string2< / code > 需要直到外部作用域结束都是有效的。Rust 知道这些是因为（< code > longest< / code > ）函数的参数和返回值都使用了相同的生命周期参数< code > 'a< / code > 。< / p >
< p > 以我们的理解< code > string1< / code > 更长，因此< code > result< / code > 会包含指向< code > string1< / code > 的引用。因为< code > string1< / code > 还未离开作用域，对于< code > println!< / code > 来说< code > string1< / code > 的引用仍然是有效的。然而，我们通过生命周期参数告诉 Rust 的是< code > longest< / code > 函数返回的引用的生命周期应该与传入参数的生命周期中较短那个保持一致。因此，借用检查器不允许列表 10-23 中的代码，因为它可能会存在无效的引用。< / p >
< p > 请尝试更多采用不同的值和不同生命周期的引用作为< code > longest< / code > 函数的参数和返回值的实验。并在开始编译前猜想你的实验能否通过借用检查器，接着编译一下看看你是否是正确的！< / p >
< a class = "header" href = "#深入理解生命周期" name = "深入理解生命周期" > < h3 > 深入理解生命周期< / h3 > < / a >
< p > 指定生命周期参数的正确方式依赖函数具体的功能。例如，如果将< code > longest< / code > 函数的实现修改为总是返回第一个参数而不是最长的字符串 slice， < code > y< / code > 指定一个生命周期。如下代码将能够编译：< / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
< pre > < code class = "language-rust" > fn longest< 'a> (x: & 'a str, y: & str) -> & 'a str {
x
}
< / code > < / pre >
< p > 在这个例子中，我们为参数< code > x< / code > 和返回值指定了生命周期参数< code > 'a< / code > ，不过没有为参数< code > y< / code > 指定，因为< code > y< / code > 的生命周期与参数< code > x< / code > 和返回值的生命周期没有任何关系。< / p >
< p > 当从函数返回一个引用，返回值的生命周期参数需要与一个参数的生命周期参数相匹配。如果返回的引用< strong > 没有< / strong > 指向任何一个参数，那么唯一的可能就是它指向一个函数内部创建的值，它将会是一个悬垂引用，因为它将会在函数结束时离开作用域。尝试考虑这个并不能编译的< code > longest< / code > 函数实现：< / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
< pre > < code class = "language-rust,ignore" > fn longest< 'a> (x: & str, y: & str) -> & 'a str {
let result = String::from(" really long string" );
result.as_str()
}
< / code > < / pre >
< p > 即便我们为返回值指定了生命周期参数< code > 'a< / code > ，这个实现却编译失败了，因为返回值的生命周期与参数完全没有关联。这里是会出现的错误信息：< / p >
< pre > < code > error: `result` does not live long enough
|
3 | result.as_str()
| ^^^^^^ does not live long enough
4 | }
| - borrowed value only lives until here
|
note: borrowed value must be valid for the lifetime 'a as defined on the block
at 1:44...
|
1 | fn longest< 'a> (x: & str, y: & str) -> & 'a str {
| ^
< / code > < / pre >
< p > 出现的问题是< code > result< / code > 在函数的结尾将离开作用域并被清理，而我们尝试从函数返回一个< code > result< / code > 的引用。无法指定生命周期参数来改变悬垂引用，而且 Rust 也不允许我们创建一个悬垂引用。在这种情况，最好的解决方案是返回一个有所有权的数据类型而不是一个引用，这样函数调用者就需要负责清理这个值了。< / p >
< p > 从结果上看， ， < / p >
< a class = "header" href = "#结构体定义中的生命周期注解" name = "结构体定义中的生命周期注解" > < h3 > 结构体定义中的生命周期注解< / h3 > < / a >
< p > 目前为止，我们只定义过有所有权类型的结构体。也可以定义存放引用的结构体，不过需要为结构体定义中的每一个引用添加生命周期注解。列表 10-24 中有一个存放了一个字符串 slice 的结构体< code > ImportantExcerpt< / code > ： < / p >
< figure >
< span class = "filename" > Filename: src/main.rs< / span >
< pre > < code class = "language-rust" > struct ImportantExcerpt< 'a> {
part: & 'a str,
}
fn main() {
let novel = String::from(" Call me Ishmael. Some years ago..." );
let first_sentence = novel.split('.')
.next()
.expect(" Could not find a '.'" );
let i = ImportantExcerpt { part: first_sentence };
}
< / code > < / pre >
< figcaption >
< p > Listing 10-24: A struct that holds a reference, so its definition needs a
lifetime annotation< / p >
< / figcaption >
< / figure >
< p > 这个结构体有一个字段，< code > part< / code > ，它存放了一个字符串 slice， ， ， < / p >
< p > 这里的< code > main< / code > 函数创建了一个< code > ImportantExcerpt< / code > 的实例，它存放了变量< code > novel< / code > 所拥有的< code > String< / code > 的第一个句子的引用。< / p >
< a class = "header" href = "#生命周期省略" name = "生命周期省略" > < h3 > 生命周期省略< / h3 > < / a >
< p > 在这一部分，我们知道了每一个引用都有一个生命周期，而且需要为使用了引用的函数或结构体指定生命周期。然而，第四章的“字符串 slice”部分有一个函数， < / p >
< figure >
< span class = "filename" > Filename: src/lib.rs< / span >
< pre > < code class = "language-rust" > fn first_word(s: & str) -> & str {
let bytes = s.as_bytes();
for (i, & item) in bytes.iter().enumerate() {
if item == b' ' {
return & s[0..i];
}
}
& s[..]
}
< / code > < / pre >
< figcaption >
< p > Listing 10-25: A function we defined in Chapter 4 that compiled without
lifetime annotations, even though the parameter and return type are references< / p >
< / figcaption >
< / figure >
< p > 这个函数没有生命周期注解却能编译是由于一些历史原因：在早期 1.0 之前的版本的 Rust 中，这的确是不能编译的。每一个引用都必须有明确的生命周期。那时的函数签名将会写成这样：< / p >
< pre > < code class = "language-rust,ignore" > fn first_word< 'a> (s: & 'a str) -> & 'a str {
< / code > < / pre >
< p > 在编写了很多 Rust 代码后， < / p >
< p > 这里我们提到一些 Rust 的历史是因为更多的明确的模式将被合并和添加到编译器中是完全可能的。未来将会需要越来越少的生命周期注解。< / p >
< p > 被编码进 Rust 引用分析的模式被称为< strong > 生命周期省略规则< / strong > （ < em > lifetime elision rules< / em > ）。这并不是需要程序员遵守的规则；这些规则是一系列特定的场景，此时编译器会会考虑，如果代码符合这些场景，就不需要明确指定生命周期。< / p >
< p > 这些规则并不提供完整的推断：如果 Rust 在明确遵守这些规则的前提下变量的生命周期仍然是模棱两可的话，它不会猜测剩余引用的生命周期应该是什么。在这种情况，编译器会给出一个错误，这可以通过增加对应引用之间相联系的生命周期注解来解决。< / p >
< p > 首先，介绍一些定义定义：函数或方法的参数的生命周期被称为< strong > 输入生命周期< / strong > （ < em > input lifetimes< / em > ），而返回值的生命周期被称为< strong > 输出生命周期< / strong > （ < em > output lifetimes< / em > ）。< / p >
< p > 现在介绍编译器用于判断引用何时不需要明确生命周期注解的规则。第一条规则适用于输入生命周期，而两条规则则适用于输出生命周期。如果编译器检查完这三条规则并仍然存在没有计算出生命周期的引用，编译器将会停止并生成错误。< / p >
< ol >
< li >
< p > 每一个是引用的参数都有它自己的生命周期参数。话句话说就是，有一个引用参数的有一个生命周期参数：< code > fn foo< 'a> (x: & 'a i32)< / code > ，有两个引用参数的函数有两个不同的生命周期参数，< code > fn foo< 'a, 'b> (x: & 'a i32, y: & 'b i32)< / code > ，依此类推。< / p >
< / li >
< li >
< p > 如果只有一个输入生命周期参数，而且它被赋予所有输出生命周期参数：< code > fn foo< 'a> (x: & 'a i32) -> & 'a i32< / code > 。< / p >
< / li >
< li >
< p > 如果方法有多个输入生命周期参数，不过其中之一是< code > & self< / code > 或< code > & mut self< / code > ，那么< code > self< / code > 的生命周期被赋予所有输出生命周期参数。这使得方法看起来更简洁。< / p >
< / li >
< / ol >
< p > 假设我们自己就是编译器并来计算列表 10-25 < code > first_word< / code > 函数的签名中的引用的生命周期。开始时签名中的引用并没有关联任何生命周期：< / p >
< pre > < code class = "language-rust,ignore" > fn first_word(s: & str) -> & str {
< / code > < / pre >
< p > 接着我们（作为编译器）应用第一条规则，也就是每个引用参数都有其自己的生命周期。我们像往常一样称之为< code > 'a< / code > ，所以现在签名看起来像这样：< / p >
< pre > < code class = "language-rust,ignore" > fn first_word< 'a> (s: & 'a str) -> & str {
< / code > < / pre >
< p > 对于第二条规则，因为这里正好只有一个输入生命周期参数所以是适用的。第二条规则表明输入参数的生命周期将被赋予输出生命周期参数，所以现在签名看起来像这样：< / p >
< pre > < code class = "language-rust,ignore" > fn first_word< 'a> (s: & 'a str) -> & 'a str {
< / code > < / pre >
< p > 现在这个函数签名中的所有引用都有了生命周期，而编译器可以继续它的分析而无须程序员标记这个函数签名中的生命周期。< / p >
< p > 让我们再看看另一个例子，这次我们从列表 10-20 中没有生命周期参数的< code > longest< / code > 函数开始：< / p >
< pre > < code class = "language-rust,ignore" > fn longest(x: & str, y: & str) -> & str {
< / code > < / pre >
< p > 再次假设我们自己就是编译器并应用第一条规则：每个引用参数都有其自己的生命周期。这次有两个参数，所有就有两个生命周期：< / p >
< pre > < code class = "language-rust,ignore" > fn longest< 'a, 'b> (x: & 'a str, y: & 'b str) -> & str {
< / code > < / pre >
< p > 再来应用第二条规则，它并不适用因为存在多于一个输入生命周期。再来看第三条规则，它同样也不适用因为没有< code > self< / code > 参数。然后我们就没有更多规则了，不过还没有计算出返回值的类型的生命周期。这就是为什么在编译列表 10-20 的代码时会出现错误的原因：编译器适用所有已知的生命周期省略规则，不过仍然不能计算出签名中所有引用的生命周期。< / p >
< p > 因为第三条规则真正能够适用的就只有方法签名，现在就让我们看看那种情况中的生命周期，并看看为什么这条规则意味着我们经常不需要在方法签名中标注生命周期。< / p >
< a class = "header" href = "#方法定义中的生命周期注解" name = "方法定义中的生命周期注解" > < h3 > 方法定义中的生命周期注解< / h3 > < / a >
<!-- Is this different to the reference lifetime annotations, or just a
finalized explanation? -->
<!-- This is about lifetimes on references in method signatures, which is where
the 3rd lifetime elision rule kicks in. It can also be confusing where lifetime
parameters need to be declared and used since the lifetime parameters could go
with the struct's fields or with references passed into or returned from
methods. /Carol -->
< p > 当为带有生命周期的结构体实现方法时，其语法依然类似列表 10-10 中展示的泛型类型参数的语法：包括声明生命周期参数的位置和以及生命周期参数是否与结构体字段或方法的参数与返回值相关联。< / p >
< p > （实现方法时）结构体字段的生命周期必须总是在< code > impl< / code > 关键字之后声明并在结构体名称之后被适用，因为这些生命周期是结构体类型的一部分。< / p >
< p > < code > impl< / code > 块里的方法签名中，引用可能与结构体字段中的引用相关联，也可能是独立的。另外，生命周期省略规则也经常让我们无需在方法签名中使用生命周期注解。让我们看看一些使用列表 10-24 中定义的结构体< code > ImportantExcerpt< / code > 的例子。< / p >
< p > 首先，这里有一个方法< code > level< / code > 。其唯一的参数是< code > self< / code > 的引用，而且返回值只是一个< code > i32< / code > ，并不引用任何值：< / p >
< pre > < code class = "language-rust" > # struct ImportantExcerpt< 'a> {
# part: & 'a str,
# }
#
impl< 'a> ImportantExcerpt< 'a> {
fn level(& self) -> i32 {
3
}
}
< / code > < / pre >
< p > < code > impl< / code > 之后和类型名称之后的生命周期参数是必要的，不过因为第一条生命周期规则我们并不必须标注< code > self< / code > 引用的生命周期。< / p >
< p > 这里是一个适用于第三条生命周期省略规则的例子：< / p >
< pre > < code class = "language-rust" > # struct ImportantExcerpt< 'a> {
# part: & 'a str,
# }
#
impl< 'a> ImportantExcerpt< 'a> {
fn announce_and_return_part(& self, announcement: & str) -> & str {
println!(" Attention please: {}" , announcement);
self.part
}
}
< / code > < / pre >
< p > 这里有两个输入生命周期，所以 Rust 应用第一条生命周期省略规则并给予< code > & self< / code > 和< code > announcement< / code > 他们各自的生命周期。接着，因为其中一个参数是< code > & self< / code > ，返回值类型被赋予了< code > & self< / code > 的生命周期，这样所有的生命周期都被计算出来了。< / p >
< a class = "header" href = "#静态生命周期" name = "静态生命周期" > < h3 > 静态生命周期< / h3 > < / a >
< p > 这里有< strong > 一种< / strong > 特殊的生命周期值得讨论：< code > 'static< / code > 。< code > 'static< / code > 生命周期存活于整个程序期间。所有的字符串字面值都拥有< code > 'static< / code > 生命周期，我们也可以选择像下面这样标注出来：< / p >
< pre > < code class = "language-rust" > let s: & 'static str = " I have a static lifetime." ;
< / code > < / pre >
< p > 这个字符串的文本被直接储存在程序的二进制文件中而这个文件总是可用的。因此所有的字符串字面值都是< code > 'static< / code > 的。< / p >
<!-- How would you add a static lifetime (below)? -->
<!-- Just like you'd specify any lifetime, see above where it shows `&'static str`. /Carol -->
< p > 你可能在错误信息的帮助文本中见过使用< code > 'static< / code > 生命周期的建议，不过将引用指定为< code > 'static< / code > 之前，思考一下这个引用是否真的在整个程序的生命周期里都有效（或者哪怕你希望它一直有效，如果可能的话）。大部分情况，代码中的问题是尝试创建一个悬垂引用或者可用的生命周期不匹配，请解决这些问题而不是指定一个< code > 'static< / code > 的生命周期。< / p >
< a class = "header" href = "#结合泛型类型参数trait-bounds-和生命周期" name = "结合泛型类型参数trait-bounds-和生命周期" > < h3 > 结合泛型类型参数、trait bounds 和生命周期< / h3 > < / a >
< p > 让我们简单的看一下在同一函数中指定泛型类型参数、trait bounds 和生命周期的语法！< / p >
< pre > < code class = "language-rust" > use std::fmt::Display;
fn longest_with_an_announcement< 'a, T> (x: & 'a str, y: & 'a str, ann: T) -> & 'a str
where T: Display
{
println!(" Announcement! {}" , ann);
if x.len() > y.len() {
x
} else {
y
}
}
< / code > < / pre >
< p > 这个是列表 10-21 中那个返回两个字符串 slice 中最长者的< code > longest< / code > 函数，不过带有一个额外的参数< code > ann< / code > 。< code > ann< / code > 的类型是泛型< code > T< / code > ，它可以被放入任何实现了< code > where< / code > 从句中指定的< code > Display< / code > trait 的类型。这个额外的参数会在函数比较字符串 slice 的长度之前被打印出来，这也就是为什么< code > Display< / code > trait bound 是必须的。因为生命周期也是泛型，生命周期参数< code > 'a< / code > 和泛型类型参数< code > T< / code > 都位于函数名后的同一尖括号列表中。< / p >
< a class = "header" href = "#总结" name = "总结" > < h2 > 总结< / h2 > < / a >
< p > 这一章介绍了很多的内容！ ， < / p >
< p > 你可能不会相信，这个领域还有更多需要学习的内容：第十七章会讨论 trait 对象，这是另一种使用 trait 的方式。第十九章会涉及到生命周期注解更复杂的场景。第二十章讲解一些高级的类型系统功能。不过接下来，让我们聊聊如何在 Rust 中编写测试，来确保代码的所有功能能像我们希望的那样工作！< / p >
< a class = "header" href = "#测试" name = "测试" > < h1 > 测试< / h1 > < / a >
< blockquote >
< p > < a href = "https://github.com/rust-lang/book/blob/master/src/ch11-00-testing.md" > ch11-00-testing.md< / a >
< br >
commit c9fd8eb1da7a79deee97020e8ad49af8ded78f9c< / p >
< / blockquote >
< blockquote >
< p > Program testing can be a very effective way to show the presence of bugs, but it is hopelessly inadequate for showing their absence.< / p >
< p > Edsger W. Dijkstra, " The Humble Programmer" (1972)< / p >
< p > 软件测试是证明 bug 存在的有效方法，而证明它们不存在时则显得令人绝望的不足。< / p >
< p > Edsger W. Dijkstra， （ ） < / p >
< / blockquote >
< p > Rust 是一个非常注重正确性的编程语言， ， ， ， < / p >
< p > 例如，我们可以编写一个叫做< code > add_two< / code > 的函数，它的签名有一个整型参数并返回一个整型值。我们可以实现并编译这个函数，而 Rust 也会进行所有的类型检查和借用检查， < strong > 不能< / strong > 检查的是，我们实现的这个函数是否返回了参数值加二后的值，而不是加 10 或者减 50！ < code > 3< / code > 给< code > add_two< / code > 函数并检查我们是否得到了< code > 5< / code > 。任何时候修改了代码我们都可以运行测试来确保没有改变任何现有测试所指定的行为。< / p >
< p > 测试是一项技能，而且我们也不能期望在一本书的一个章节中就涉及到编写好的测试的所有内容。然而我们可以讨论的是 Rust 测试功能的机制。我们会讲到编写测试时会用到的注解和宏， < / p >
< a class = "header" href = "#编写测试" name = "编写测试" > < h2 > 编写测试< / h2 > < / a >
< blockquote >
< p > < a href = "https://github.com/rust-lang/book/blob/master/src/ch11-01-writing-tests.md" > ch11-01-writing-tests.md< / a >
< br >
commit 77370c073661548dd56bbcb43cc64713585acbba< / p >
< / blockquote >
< / div >
yang yue
8 years ago