Rust：临时变量的生命周期

Rust中临时变量的生命周期是一个复杂但经常被忽略的话题。在通常情况下，Rust将临时变量保留足够长的时间，这样我们就不必考虑它们的生命周期了。然而，在很多情况下，这并不能满足我的需求。

在这篇文章中，我们重新了解临时变量的生命周期规则，分析一些延长临时变量生命周期的用例。

临时变量

下面是一个没有上下文的Rust语句，它使用了一个临时字符串变量：

f(&String::from(''));

这个临时字符串存在多长时间？如果我们设计Rust语言，我们基本上可以从两种选项中选择：

• 在调用f之前，字符串会被立即删除。
• 字符串只会在调用f之后被删除。

如果我们使用选项1，上面的语句将总是导致借用检查错误，因为我们不能让f借用已经不存在的东西。

因此，Rust选择了选项2：首先分配String，然后将对它的引用传递给f，只有在f调用返回后才删除临时String。

在let语句中

现在有一个稍微难一点的问题：

let a = f(&String::from(''));
…
g(&a);

再问一次：临时字符串变量的生命周期是多长？

• 字符串在let语句的末尾被删除，在f返回之后，但在g被调用之前。
• 在调用g之后，字符串将与a同时被丢弃。

这一次，选项1可能有效，取决于f的签名。如果f被定义为fn f(s: &str) -> usize，那么在let语句之后立即删除String是完全可以的。

然而，如果f被定义为fn f(s: &str) -> &[u8]，那么a将从临时String变量中产生借用，因此如果我们将a保留更长时间，我们将得到一个借用检查错误。

对于选项2，它在两种情况下都可以很好地编译，但是我们可能会保留一个临时变量比必要的存活时间更长，这可能会浪费资源或导致微妙的错误(例如，当MutexGuard比预期的更晚被丢弃时，会出现死锁)。

在选项1和选项2之间，Rust选择了选项1：在let语句末尾删除临时变量。手动将String移动到单独的let语句中以使其保持更长的生命周期。

let s = String::from('');
let a = f(&s);
…
g(&a);

在嵌套调用中

再看一个更复杂的：

g(f(&String::from('')));

同样，有两种选择：

• 在调用f之后，但在调用g之前，字符串被删除。
• 该字符串将在语句结束时删除，因此在调用g之后。

该代码段与前一个代码段几乎相同：将对临时String变量的引用传递给f，并将其返回值传递给g。不过，这一次，使用了单个的嵌套调用表达式语句。

根据f的签名，选项1可能起作用，也可能不起作用，选项2可能使临时变量的生命周期存在的时间比必要的长。

选项1会使像String::from('').as_bytes().contains(&0x80)这样简单的东西也不会通过编译，因为字符串会被丢弃在as_bytes[f]之后，在contains[g]之前。

因此，Rust选择了选项2：不管f的签名是什么，String都保持存活，直到语句结束，直到调用g之后。

在if语句中

现在让我们来看一个简单的if语句：

if f(&String::from('')) {
    …
}

同样的问题：什么时候删除临时字符串变量？

• 在if语句的条件求值之后，但在if语句体执行之前(即在{处)。
• 在if函数体之后(即在}处)。

在这种情况下，没有理由在if语句体期间保持临时变量的存活。该条件的结果是一个布尔值(只有true或false)，根据定义，它不借用任何东西。

所以，Rust选择了选项1。

一个有用的例子是使用Mutex::lock，它返回一个临时的MutexGuard，当它被丢弃时将解锁互斥锁：

fn example(m: &Mutex<String>) {
    if m.lock().unwrap().is_empty() {
        println!("the string is empty!");
    }
}

这里，m.lock().unwrap()中的临时变量MutexGuard在.is_empty()之后被删除，这样在println语句期间互斥量就不会不必要地保持锁定状态。

在if let语句中

但是，if let和match的情况不同，因为我们的表达式不一定求值为布尔值：

if let … = f(&String::from('')) {
    …
}

还是有两种选择：

• 在模式匹配之后，在if let的主体之前(即在{处)删除字符串。
• 在if let语句体之后(即在}处)删除该字符串。

这一次，我们有理由选择第二种而不是第一种。在if let语句或match这种模式匹配语句中，借用某些东西是很常见的。

因此，在这种情况下，Rust选择了选项2。例如，如果我们有一个Mutex<Vec>类型的vec，下面的代码编译得很好：

if let Some(x) = vec.lock().unwrap().first() {
    // 互斥对象仍然被锁在这里
    // 因为我们从Vec中借用了x. (`x` 是 `&T`)
    println!("first item in vec: {x}");
}

我们从.lock().unwrap()中获得一个临时变量MutexGuard，并使用.first()方法借用第一个元素。这个借用在if let的整个主体中需要持续锁定，因此MutexGuard只在最后的}处被删除。

然而，在某些情况下，这并不是我们想要的。例如，如果我们不使用first，而是使用pop，它返回一个值而不是引用：

if let Some(x) = vec.lock().unwrap().pop() {
    // 互斥对象仍然被锁在这里
    // 这是不必要的，因为我们没有从Vec中借用任何东西。(“x” 是 “T”)
    println!("popped item from the vec: {x}");
}

这可能会导致细微的错误或性能降低。

目前，解决方法是使用单独的let语句，将临时生命周期限制为let语句中：

let x = vec.lock().unwrap().pop(); // MutexGuard在此语句之后被删除
if let Some(x) = x {
    …
}