生命周期
一个变量的生命周期就是它从创建到销毁的整个过程。
作用域
我们声明的每个变量都有作用域。作用域其实是变量和值存在的环境。作用域是由一对花括号表示的。例如，使用块表达式会创建一个作用域，即任何以花括号开头和结尾的表达式。此外，作用域支持互相嵌套，并且可以在子作用域中访问父作用域的元素，但反过来不行。
{
let a = "hello"; ----------+-- a的作用域
let b = 1; -----+--b |
{ | |
let c = true; ---+--c | |
| | |
---+ | |
} | |
---------+ |
--------------+
}当作用域结束时，作用域内定义的变量都会运行相关代码以释放资源。对于在堆栈上分配的数据，可以轻松地判定变量是否存续。对在堆上分配的值， drop 方法会被放在作用域结束标记}之前调用。但这里是隐式的，可以避免程序员忘记释放值。 drop 方法来自 Drop 特征，它是为 Rust 中大部分堆分配类型实现的，可以轻松地自动释放资源。
生命周期&作用域
Rust的生命周期是基于作用域的，我们可以认为变量的生命周期就是其作用域； 编译器能自动识别作用域内这些变量的生命周期，方便进行管理。其实生命周期纯粹是一个编译期构造，它可以帮助编译器确定某个引用有效的作用域，并确保它遵循借用规则。它可以跟踪诸如引用的来源，以及它们是否比借用值生命周期更长这类事情。Rust 中的生命周期能够确保引用的存续时间不超过它指向的值。生命周期并不是作为开发人员要用到的，而是编译器使用和推断引用的有效性时会用到的。
{
let a = "hello"; ----------+-- a生命周期
let b = 1; -----+--b |
{ | |
let c = true; ---+--c | |
| | |
---+ | |
} | |
---------+ |
--------------+
}所有权的转移
由于变量会在作用域结束时，会自动释放。如果我们需要在其作用域外继续使用它，要么转移所有权， 要么按位复制，就可以继续使用， 这取决于该变量是复制语义还是移动语义的。
如果有其他变量进入了作用域，也是会发生所有权的变化；要么转移所有权， 要么按位复制， 这取决于该变量是复制语义还是移动语义的。
{
let a = "hello".to_string();
let b = 1;
let c_out;
let d_out;
{
let c_in = 2;
let d_in = "world".to_string();
a;
b;
c_out = c_in;
d_out = d_in;
}
//println!("a:{}",a);
println!("b:{}",b);
println!("c_out:{}",c_out);
//println!("c_in:{}",c_in);
//println!("d_in:{}",d_in);
println!("d_out:{}",d_out);
}
b:1
c_out:2
d_out:world如果我们要把打印a的注释去掉，就会产生如下错误，a进入子作用域之后，发生所有权转移，在自作用结束的时候，释放了a，所以我们继续使用就会报错了。
去掉c_in的打印，则会产生如下错误，c_in也是如此。
创建新的作用域
- 可以使用块表达式（花括号）创建作用域。
{
let a = "hello".to_string();
let b = 1;
let c_out;
let d_out;
{
let c_in = 2;
let d_in = "world".to_string();
a;
b;
c_out = c_in;
d_out = d_in;
}
//println!("a:{}",a);
println!("b:{}",b);
println!("c_out:{}",c_out);
//println!("c_in:{}",c_in);
//println!("d_in:{}",d_in);
println!("d_out:{}",d_out);
}- match匹配也会产生一个作用域。
- for、 loop以及while循环语句均可以创建新的作用域。
- if let块和while let块也会创建新的作用域。
这三者都是类似，我们以match为例，演示一下。如果t换成是Some(6)，就没有问题，因为t是Option<i32>，具有复制语义了。
fn main(){
let t = Some("test".to_string());
match t{
Some(v) => (),
None => (),
}
//println!("t:{}",t);
}去掉注释之后，报错如下，说明t已经在Some（v）=> ()发生了所有权的转移，然后在作用域结束时被释放掉了；
- 函数体本身是独立的作用域。
由于String是移动语义，当它作为参数传入f函数后，发生了所有权转移，如果在main函数中再次调用就会发生错误。
fn f(t:String){
println!("{:?}",t);
}
fn main(){
let t = Some("test".to_string());
f(t);
//println!("{:?}",t);
}- 闭包
闭包会创建新的作用域， 对于环境变量来说有以下三种捕获方式：
· 对于复制语义类型， 以不可变引用（&T） 来捕获。
· 对于移动语义类型， 执行移动语义（move） 转移所有权来捕获。
· 对于可变绑定， 如果在闭包中包含对其进行修改的操作， 则以可变引用（&mut） 来捕获。
fn main(){
let t = Some("test".to_string());
let c = |i: i32|{
//println!("{:?},{:?}",t,i);
t;
};
c(0);
//println!("{:?}",t);
}这里还有一个比较有意思的地方，就是println!("{:?},{:?}",t,i);如果在闭包里只有这一句；没有t; 则不会发生所有权的转移；即println不发生所有权的转移，他表面调用的时候t，实际的参数&t；