上一篇章末尾提到，如果仅仅支持通过转移所有权的方式获取一个值，那会让程序变得复杂。 Rust 能否像其它编程语言一样，使用某个变量的指针或者引用呢？答案是可以。
Rust 通过 借用(Borrowing) 这个行为来达成上述的目的，获取变量的引用操作，称之为借用(borrowing)。
正如现实生活中，如果一个人拥有某样东西，你可以从他那里借来，当使用完毕后，也必须要物归原主。
（一）引用与解引用
常规引用是一个指针类型，指向了对象存储的内存地址。在下面代码中，我们创建一个 i32 值的引用 y，然后使用解引用运算符“ * ”来解出 y 所使用的值:
fn main() {let x = 5;let y = &x;assert_eq!(5, x);assert_eq!(5, *y);
}
assert_eq! ：是一个“断言宏”，可以用于判断两个表达式返回的值是否相等。当不相等时，当前程序会直接报错。
变量 x 存放了一个 i32 值 5。y 是 x 的一个引用。可以直接断言判断 x 等于 5。
然而，如果希望对 y 的值做出断言判断，必须使用 *y 来解出引用所指向的值（也就是解引用）。一旦解引用了 y，就可以访问 y 所指向的整型值并可以与 5 做比较。
相反如果不进行解引用，而直接编写“assert_eq!(5, y); ”，则会得到如下编译错误：
error[E0277]: can't compare `{integer}` with `&{integer}`
assert_eq!(5, y);
^^^^^^^^^^^^^^^^^ no implementation for `{integer} == &{integer}` // 无法比较整数类型和引用类型
不允许比较整数与引用，因为它们是不同的类型。必须使用解引用运算符解出引用所指向的值。
（二）不可变引用
下面的代码，我们用 s1 的引用作为参数传递给 calculate_length 函数，而不是把 s1 的所有权转移给该函数：
fn main() {let s1 = String::from("hello");let len = calculate_length(&s1); //将引用传递给函数，此时函数获取到了值而没有拿到所有权println!("The length of '{}' is {}.", s1, len);
}fn calculate_length(s: &String) -> usize {s.len() //函数返回字符串长度值
}
能注意到两点：
- 无需像上章一样：先通过函数参数传入所有权，然后再通过函数返回来传出所有权，代码更加简洁
- calculate_length 的参数 s 类型从 String 变为 &String
这里，& 符号即是引用，它们允许你使用值，但是不让获取所有权，如图所示： 
通过 &s1 语法，我们创建了一个指向 s1 的引用，但是并不拥有它。因为并不拥有这个值，当引用离开作用域后，其指向的值也不会被丢弃。
同理，函数 calculate_length 使用 & 来表明参数 s 的类型是一个引用：
fn calculate_length(s: &String) -> usize { // s 是对 String 的引用s.len()
} // 这里，s 离开了作用域。但因为它并不拥有引用值的所有权，所以什么也不会发生
一个形象的例子：我们进行了借用的行为，在理论上我们拿到的只是一个值。在此前提下，如果尝试修改借用的变量呢？
fn main() {let s = String::from("hello");change(&s);
}fn change(some_string: &String) {some_string.push_str(", world");
}
果然，这种修改是不被允许的：
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` referencefn change(some_string: &String) {------- help: consider changing this to be a mutable reference: `&mut String`//------- 帮助：考虑将该参数类型修改为可变的引用: `&mut String`
some_string.push_str(", world");^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable//some_string`是一个`&`类型的引用，因此它指向的数据无法进行修改
正如变量默认不可变一样，引用指向的值默认也是不可变的。
如果我们要对其进行修改，那么只需要进行一个小调整，即可解决这个问题。
（三）可变引用
只需要一个小调整，即可修复上面代码的错误：
fn main() {let mut s = String::from("hello"); //将s设置为可变change(&mut s); //传递引用时使其可变
}fn change(some_string: &mut String) { //相应的，参数为可变some_string.push_str(", world");
}
首先，声明 s 是可变类型，其次创建一个可变的引用 &mut s 和接受可变引用参数 some_string: &mut String 的函数。
1. 注意：可变引用同时只能存在一个
不过可变引用并不是随心所欲、想用就用的，它有一个很大的限制：同一作用域，特定数据在每个时刻中只能有一个可变引用存在：
let mut s = String::from("hello");let r1 = &mut s;
let r2 = &mut s;println!("{}, {}", r1, r2);
以上代码会报错，错误信息如下：
error[E0499]: cannot borrow `s` as mutable more than once at a time 同一时间无法对 `s` 进行两次可变借用|
3 | let r1 = &mut s;| ------ first mutable borrow occurs here 首个可变引用在这里借用
4 | let r2 = &mut s;| ^^^^^^ second mutable borrow occurs here 第二个可变引用在这里借用
6 | println!("{}, {}", r1, r2);| -- first borrow later used here 第一个借用在这里使用
这段代码出错的原因在于：第一个对 s 的进行可变借用的 r1 必须要持续到最后一次使用的位置 println!，在 r1 创建和最后一次使用之间，我们又创建了第二个可变借用 r2。
这种限制的好处就是使 Rust 在编译期就避免数据竞争，数据竞争可由以下行为造成：
- 两个或更多的指针同时访问同一数据
- 至少有一个指针被用来写入数据
- 没有同步数据访问的机制
数据竞争会导致发生不可预知的行为，这种行为难以在运行时追踪，并且难以诊断和修复。
而 Rust 它不会编译存在数据竞争的代码，所以避免了这种情况的发生。
很多时候，大括号可以帮我们解决一些编译不通过的问题，通过手动限制变量的作用域：
let mut s = String::from("hello");{let r1 = &mut s;} // r1 在这里离开了作用域，所以我们完全可以创建一个新的引用let r2 = &mut s;
2. 注意：可变引用与不可变引用不能同时存在
下面的代码会导致一个错误：
let mut s = String::from("hello");let r1 = &s; // 没问题
let r2 = &s; // 没问题
let r3 = &mut s; // 大问题println!("{}, {}, and {}", r1, r2, r3);
错误如下：
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable// 无法借用可变 `s` 因为它已经被借用了不可变|
4 | let r1 = &s; // 没问题| -- immutable borrow occurs here 不可变借用发生在这里
5 | let r2 = &s; // 没问题
6 | let r3 = &mut s; // 大问题| ^^^^^^ mutable borrow occurs here 可变借用发生在这里
7 |
8 | println!("{}, {}, and {}", r1, r2, r3);| -- immutable borrow later used here 不可变借用在这里使用
其实这个也很好理解，正在借用不可变引用的用户，肯定不希望他借用的东西，被另外一个人莫名其妙改变了。
“对于一个数据（变量），可以同时存在多个对它的不可变引用” 是因为没有人会去试图修改数据，每个人都只读这一份数据而不做修改，因此不用担心数据被污染。
注意，引用的作用域 s 从创建开始，一直持续到它最后一次使用的地方，这个跟变量的作用域有所不同。变量的作用域是从创建的位置向下持续到作用域的关闭花括号“ } ”
Rust 的编译器一直在优化，早期的时候，引用的作用域跟变量作用域是一致的，这对日常使用带来了很大的困扰，你必须非常小心的去安排可变、不可变变量的借用，免得无法通过编译，例如以下代码：
fn main() {let mut s = String::from("hello");let r1 = &s;let r2 = &s;println!("{} and {}", r1, r2);// 新编译器中，r1,r2作用域在这里结束let r3 = &mut s;println!("{}", r3);
} // 老编译器中，r1、r2、r3作用域在这里结束
// 新编译器中，r3作用域在这里结束
在老版本的编译器中（Rust 1.31 前），将会报错，因为 r1 和 r2 的作用域在花括号 } 处结束，那么 r3 的借用就会触发 无法同时借用可变和不可变的规则。
但是在新的编译器中，该代码将顺利通过，因为Rust新规定了：“引用作用域的结束位置从花括号变成最后一次使用的位置”，因此 r1 借用和 r2 借用在 println! 后，就结束了，此时 r3 可以顺利借用到可变引用。
所以便对应了开头提到的“你可以从他那里借来，当使用完毕后，也必须要物归原主。”
对于这种编译器优化行为，Rust 专门起了一个名字 —— Non-Lexical Lifetimes(NLL)，专门用于找到某个引用在作用域 ( } ) 结束前就不再被使用的代码位置。
虽然这种借用错误有的时候会让我们很郁闷，但其实也是 Rust 提前发现了潜在的 BUG，即使减慢了开发速度，但是从长期来看却大幅减少了后续开发和运维成本。
（四）悬垂引用
悬垂引用也叫做悬垂指针，意思为指针指向某个值后，当这个值被释放掉时，指针仍然存在，但其指向的内存可能不存在任何值或已被其它变量重新使用。
在 Rust 中编译器中，可以确保引用永远也不会变成悬垂状态：当你获取数据的引用后，编译器可以确保数据不会在引用结束前被释放，要想释放数据，必须先停止（结束）其引用的使用。
让我们尝试创建一个悬垂引用，Rust 会抛出一个编译时错误：
fn main() {let reference_to_nothing = dangle();
}fn dangle() -> &String {let s = String::from("hello");&s
}
这里是错误：
error[E0106]: missing lifetime specifier|
5 | fn dangle() -> &String {| ^ expected named lifetime parameter|= help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime|
5 | fn dangle() -> &'static String {| ~~~~~~~~
错误信息引用了一个我们还未学习的概念：lifetime（生命周期）。不过，即使不理解生命周期，也可以通过错误信息知道这段代码错误的关键信息：
this function's return type contains a borrowed value, but there is no value for it to be borrowed from.
该函数返回了一个借用的值，但是已经找不到它所借用值的来源
仔细看看 dangle 代码的每一步到底发生了什么：
fn dangle() -> &String { // dangle 返回一个字符串的引用let s = String::from("hello"); // s 是一个新字符串&s // 返回字符串 s 的引用
} // 这里 s 离开作用域并被丢弃。其内存被释放。
// 危险！
因为 s 是在 dangle 函数内创建的，当 dangle 的代码执行完毕后，s 将被释放，但是此时我们又尝试去返回它的引用。这意味着这个引用会指向一个无效的 String，这可不对！
其中一个很好的解决方法是直接返回 String：
fn no_dangle() -> String {let s = String::from("hello");s
}
这样就没有任何错误了，最终 String 的 所有权被转移给外面的调用者。
引用的规则
让我们概括一下对引用的讨论：
- 在任何时刻，要么 只能有一个可变引用，要么 只能有多个不可变引用。
- 引用必须总是有效的。
