共计 21461 个字符，预计需要花费 54 分钟才能阅读完成。
作者：京东批发 周凯
一. 前言
Rust 语言由 Mozilla 开发，最早公布于 2014 年 9 月，是一种高效、牢靠的通用高级语言。其高效不仅限于开发效率，它的执行效率也是令人称誉的，是一种少有的兼顾开发效率和执行效率的语言。Rust 语言具备如下个性：
•高性能 – Rust 速度惊人且内存利用率极高。因为没有运行时和垃圾回收，它可能胜任对性能要求特地高的服务，能够在嵌入式设施上运行，还能轻松和其余语言集成。
•可靠性 – Rust 丰盛的类型零碎和所有权模型保障了内存平安和线程平安，让您在编译期就可能打消各种各样的谬误。
•生产力 – Rust 领有杰出的文档、敌对的编译器和清晰的谬误提示信息，还集成了一流的工具 —— 包管理器和构建工具，智能地主动补全和类型测验的多编辑器反对，以及主动格式化代码等等。
Rust 最近几年倒退十分迅速，广受一线程序员的欢送，Rust 有一个官网保护的模块库（crates.io: Rust Package Registry），能够通过编译器自带的 cargo 管理工具不便的引入模块，目前 crates.io 下面的模块数量曾经冲破 10 万个，仍在快速增长，此情此景好像过来 10 年 node.js 的倒退情景再现。
12 月 11 日，Linus Torvalds 公布了 Linux6.1 内核稳定版，并带来一个重磅的新闻，即 Linux6.1 将蕴含对 Rust 语言的原生反对。只管这一性能仍在构建中，不过这也意味着，在可见的未来，Linux 的历史将打开簇新的一页——除了 C 之外，开发人员将第一次可能应用另一种语言 Rust 进行内核开发。
在近几年的探讨中，是否在 Linux 内核中引入 Rust 屡次成为议题。不过包含 Torvalds 在内的一众关键人物均对此示意了期待。早在 2019 年，Alex Gaynor 和 Geoffrey Thomas 就曾于 Linux Security Summit 平安峰会上进行了演讲。他们指出，在 Android 和 Ubuntu 中，约有三分之二的内核破绽被调配到 CVE 中，这些破绽都是来自于内存平安问题。原则上，Rust 能够通过其 type system 和 borrow checker 所提供的更平安的 API 来完全避免这类谬误。简言之，Rust 比 C 更平安。谷歌 Android 团队的 Wedson Almeida Filho 也曾公开示意：“咱们感觉 Rust 当初曾经筹备好退出 C 语言，作为实现内核的实用语言。它能够帮忙咱们缩小特权代码中潜在谬误和安全漏洞的数量，同时很好地与外围内核配合并保留其性能特色。”
以后，谷歌在 Android 中宽泛应用 Rust。在那里，“指标不是将现有的 C /C++ 转换为 Rust，而是随着工夫的推移，将新代码的开发转移到内存平安语言”。这一舆论也逐步在实践中失去论证。“随着进入 Android 的新内存不平安代码的数量缩小，内存安全漏洞的数量也在缩小。从 2019 年到 2022 年，相干破绽占比已从 Android 总破绽的 76% 降落到 35%。2022 年，在 Android 破绽排行中，内存安全漏洞第一次不再是主因。”
本文将探寻相比于其余语言，Rust 是怎么实现内存平安的。Rust 针对创立于内存堆上的简单数据类型，设计了一套独有的内存管理机制，该套机制蕴含变量的所有权机制、变量的作用域、变量的援用与借用，并专门针对字符串、数组、元组等简单类型设计了 slice 类型，上面将具体讲述这些机制与规定。
二. 变量的所有权
Rust 的外围性能（之一）是 所有权（ownership）。尽管该性能很容易解释，但它对语言的其余局部有着粗浅的影响。
所有程序都必须治理其运行时应用计算机内存的形式。一些语言中具备垃圾回收机制，在程序运行时有法则地寻找不再应用的内存；在另一些语言中，程序员必须亲自调配和开释内存。Rust 则抉择了第三种形式：通过所有权系统管理内存，编译器在编译时会依据一系列的规定进行查看。如果违反了任何这些规定，程序都不能编译。在运行时，所有权零碎的任何性能都不会减慢程序。
因为所有权对很多程序员来说都是一个新概念，须要一些工夫来适应。好消息是随着你对 Rust 和所有权零碎的规定越来越有教训，你就越能天然地编写出平安和高效的代码。坚持不懈！
当你了解了所有权，你将有一个松软的根底来了解那些使 Rust 独特的性能。在本章中，咱们将通过实现一些示例来介绍所有权，这些示例基于一个罕用的数据结构：字符串。
栈（Stack）与堆（Heap）在很多语言中，你并不需要常常思考到栈与堆。不过在像 Rust 这样的零碎编程语言中，值是位于栈上还是堆上在更大程度上影响了语言的行为以及为何必须做出这样的抉择。咱们会在本文的稍后局部形容所有权与栈和堆相干的内容，所以这里只是一个用来预热的简要解释。栈和堆都是代码在运行时可供使用的内存，然而它们的构造不同。栈以放入值的顺序存储值并以相同程序取出值。这也被称作 后进先出（last in, first out）。设想一下一叠盘子：当减少更多盘子时，把它们放在盘子堆的顶部，当须要盘子时，也从顶部拿走。不能从两头也不能从底部减少或拿走盘子！减少数据叫做 进栈（pushing onto the stack），而移出数据叫做 出栈（popping off the stack）。栈中的所有数据都必须占用已知且固定的大小。在编译时大小未知或大小可能变动的数据，要改为存储在堆上。堆是不足组织的：当向堆放入数据时，你要申请肯定大小的空间。内存分配器（memory allocator）在堆的某处找到一块足够大的空位，把它标记为已应用，并返回一个示意该地位地址的 指针（pointer）。这个过程称作 在堆上分配内存（allocating on the heap），有时简称为“调配”（allocating）。（将数据推入栈中并不被认为是调配）。因为指向放入堆中数据的指针是已知的并且大小是固定的，你能够将该指针存储在栈上，不过当须要理论数据时，必须拜访指针。设想一上来餐馆就座吃饭。当进入时，你阐明有几个人，餐馆员工会找到一个够大的空桌子并领你们过来。如果有人来迟了，他们也能够通过询问来找到你们坐在哪。入栈比在堆上分配内存要快，因为（入栈时）分配器无需为存储新数据去搜寻内存空间；其地位总是在栈顶。相比之下，在堆上分配内存则须要更多的工作，这是因为分配器必须首先找到一块足够存放数据的内存空间，并接着做一些记录为下一次调配做筹备。拜访堆上的数据比拜访栈上的数据慢，因为必须通过指针来拜访。古代处理器在内存中跳转越少就越快（缓存）。持续类比，假如有一个服务员在餐厅里解决多个桌子的点菜。在一个桌子报完所有菜后再挪动到下一个桌子是最有效率的。从桌子 A 听一个菜，接着桌子 B 听一个菜，而后再桌子 A，而后再桌子 B 这样的流程会更加迟缓。出于同样起因，处理器在解决的数据彼此较近的时候（比方在栈上）比拟远的时候（比方可能在堆上）能更好的工作。当你的代码调用一个函数时，传递给函数的值（包含可能指向堆上数据的指针）和函数的局部变量被压入栈中。当函数完结时，这些值被移出栈。跟踪哪局部代码正在应用堆上的哪些数据，最大限度的缩小堆上的反复数据的数量，以及清理堆上不再应用的数据确保不会耗尽空间，这些问题正是所有权零碎要解决的。一旦了解了所有权，你就不须要常常思考栈和堆了，不过明确了所有权的次要目标就是为了治理堆数据，可能帮忙解释为什么所有权要以这种形式工作。
2.1. 所有权规定
首先，让咱们看一下所有权的规定。当咱们通过举例说明时，请谨记这些规定：
Rust 中的每一个值都有一个 所有者（owner）。值在任一时刻有且只有一个所有者。当所有者（变量）来到作用域，这个值将被抛弃。
2.2. 变量作用域
既然咱们曾经把握了根本语法，将不会在之后的例子中蕴含 fn main() { 代码，所以如果你是一路跟过去的，必须手动将之后例子的代码放入一个 main 函数中。这样，例子将显得更加扼要，使咱们能够关注理论细节而不是样板代码。
在所有权的第一个例子中，咱们看看一些变量的 作用域（scope）。作用域是一个项（item）在程序中无效的范畴。假如有这样一个变量：
let s = "hello";变量 s 绑定到了一个字符串字面值，这个字符串值是硬编码进程序代码中的。这个变量从申明的点开始直到以后 作用域 完结时都是无效的。示例 1 中的正文表明了变量 s 在何处是无效的。
{ // s 在这里有效, 它尚未申明
let s = "hello"; // 从此处起，s 是无效的
// 应用 s
} // 此作用域已完结，s 不再无效示例 1：一个变量和其无效的作用域
换句话说，这里有两个重要的工夫点：
•当 s 进入作用域 时，它就是无效的。
•这始终继续到它 来到作用域 为止 。
目前为止，变量是否无效与作用域的关系跟其余编程语言是相似的。当初咱们在此基础上介绍 String 类型。
2.3.String 类型
为了演示所有权的规定，咱们须要一个比根本数据类型都要简单的数据类型。后面介绍的类型都是已知大小的，能够存储在栈中，并且当来到作用域时被移出栈，如果代码的另一部分须要在不同的作用域中应用雷同的值，能够疾速简略地复制它们来创立一个新的独立实例。不过咱们须要寻找一个存储在堆上的数据来摸索 Rust 是如何晓得该在何时清理数据的。
咱们会专一于 String 与所有权相干的局部。这些方面也同样实用于规范库提供的或你本人创立的其余简单数据类型。
咱们曾经见过字符串字面值，即被硬编码进程序里的字符串值。字符串字面值是很不便的，不过它们并不适宜应用文本的每一种场景。起因之一就是它们是不可变的。另一个起因是并非所有字符串的值都能在编写代码时就晓得：例如，要是想获取用户输出并存储该怎么办呢？为此，Rust 有第二个字符串类型，String。这个类型治理被调配到堆上的数据，所以可能存储在编译时未知大小的文本。能够应用 from 函数基于字符串字面值来创立 String，如下：
let s = String::from("hello");这两个冒号 :: 是运算符，容许将特定的 from 函数置于 String 类型的命名空间（namespace）下，而不须要应用相似 string_from 这样的名字。
能够 批改此类字符串：
let mut s = String::from("hello");
s.push_str(", world!"); // push_str() 在字符串后追加字面值
println!("{}", s); // 将打印 `hello, world!`那么这里有什么区别呢？为什么 String 可变而字面值却不行呢？区别在于两个类型对内存的解决上。
2.4. 内存与调配
就字符串字面值来说，咱们在编译时就晓得其内容，所以文本被间接硬编码进最终的可执行文件中。这使得字符串字面值疾速且高效。不过这些个性都只得益于字符串字面值的不可变性。可怜的是，咱们不能为了每一个在编译时大小未知的文本而将一块内存放入二进制文件中，并且它的大小还可能随着程序运行而扭转。
对于 String 类型，为了反对一个可变，可增长的文本片段，须要在堆上调配一块在编译时未知大小的内存来寄存内容。这意味着：
•必须在运行时向内存分配器（memory allocator）申请内存。
•须要一个当咱们解决完 String 时将内存返回给分配器的办法。
第一局部由咱们实现：当调用 String::from 时，它的实现 (implementation) 申请其所需的内存。这在编程语言中是十分通用的。
然而，第二局部实现起来就各有区别了。在有 垃圾回收（garbage collector，GC）的语言中，GC 记录并革除不再应用的内存，而咱们并不需要关怀它。在大部分没有 GC 的语言中，辨认出不再应用的内存并调用代码显式开释就是咱们的责任了，跟申请内存的时候一样。从历史的角度上说正确处理内存回收已经是一个艰难的编程问题。如果遗记回收了会节约内存。如果过早回收了，将会呈现有效变量。如果反复回收，这也是个 bug。咱们须要准确的为一个 allocate 配对一个 free。
Rust 采取了一个不同的策略：内存在领有它的变量来到作用域后就被主动开释。上面是示例 1 中作用域例子的一个应用 String 而不是字符串字面值的版本：
{let s = String::from("hello"); // 从此处起，s 是无效的
// 应用 s
} // 此作用域已完结，// s 不再无效这是一个将 String 须要的内存返回给分配器的很天然的地位：当 s 来到作用域的时候。当变量来到作用域，Rust 为咱们调用一个非凡的函数。这个函数叫做 drop，在这里 String 的作者能够搁置开释内存的代码。Rust 在结尾的 } 处主动调用 drop。
留神：在 C++ 中，这种 item 在生命周期完结时开释资源的模式有时被称作 资源获取即初始化（Resource Acquisition Is Initialization (RAII)）。如果你应用过 RAII 模式的话应该对 Rust 的 drop 函数并不生疏。
这个模式对编写 Rust 代码的形式有着深远的影响。当初它看起来很简略，不过在更简单的场景下代码的行为可能是不可预测的，比方当有多个变量应用在堆上调配的内存时。当初让咱们摸索一些这样的场景。
2.4.1. 变量与数据交互的形式（一）：挪动
在 Rust 中，多个变量能够采取不同的形式与同一数据进行交互。让咱们看看示例 2 中一个应用整型的例子。
let x = 5;
let y = x;示例 2：将变量 x 的整数值赋给 y
咱们大抵能够猜到这在干什么：“将 5 绑定到 x；接着生成一个值 x 的拷贝并绑定到 y”。当初有了两个变量，x 和 y，都等于 5。这也正是事实上产生了的，因为整数是有已知固定大小的简略值，所以这两个 5 被放入了栈中。
当初看看这个 String 版本：
let s1 = String::from("hello");
let s2 = s1;这看起来与下面的代码十分相似，所以咱们可能会假如他们的运行形式也是相似的：也就是说，第二行可能会生成一个 s1 的拷贝并绑定到 s2 上。不过，事实上并不齐全是这样。
看看图 1 以理解 String 的底层会产生什么。String 由三局部组成，如图左侧所示：一个指向寄存字符串内容内存的指针，一个长度，和一个容量。这一组数据存储在栈上。右侧则是堆上寄存内容的内存局部。
图 1：将值 “hello” 绑定给 s1 的 String 在内存中的表现形式
长度示意 String 的内容以后应用了多少字节的内存。容量是 String 从分配器总共获取了多少字节的内存。长度与容量的区别是很重要的，不过在以后上下文中并不重要，所以当初能够疏忽容量。
当咱们将 s1 赋值给 s2，String 的数据被复制了，这意味着咱们从栈上拷贝了它的指针、长度和容量。咱们并没有复制指针指向的堆上数据。换句话说，内存中数据的体现如图 2 所示。
图 2：变量 s2 的内存体现，它有一份 s1 指针、长度和容量的拷贝
这个表现形式看起来 并不像 图 3 中的那样，如果 Rust 也拷贝了堆上的数据，那么内存看起来就是这样的。如果 Rust 这么做了，那么操作 s2 = s1 在堆上数据比拟大的时候会对运行时性能造成十分大的影响。
图 3：另一个 s2 = s1 时可能的内存体现，如果 Rust 同时也拷贝了堆上的数据的话
之前咱们提到过当变量来到作用域后，Rust 主动调用 drop 函数并清理变量的堆内存。不过图 2 展现了两个数据指针指向了同一地位。这就有了一个问题：当 s2 和 s1 来到作用域，他们都会尝试开释雷同的内存。这是一个叫做 二次开释（double free）的谬误，也是之前提到过的内存安全性 bug 之一。两次开释（雷同）内存会导致内存净化，它可能会导致潜在的安全漏洞。
为了确保内存平安，在 let s2 = s1 之后，Rust 认为 s1 不再无效，因而 Rust 不须要在 s1 来到作用域后清理任何货色。看看在 s2 被创立之后尝试应用 s1 会产生什么；这段代码不能运行：
let s1 = String::from("hello");
let s2 = s1;
println!("{}, world!", s1);你会失去一个相似如下的谬误，因为 Rust 禁止你应用有效的援用。
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0382]: borrow of moved value: `s1`
--> src/main.rs:5:28
|
2 | let s1 = String::from("hello");
| -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
3 | let s2 = s1;
| -- value moved here
4 |
5 | println!("{}, world!", s1);
| ^^ value borrowed here after move
For more information about this error, try `rustc --explain E0382`.
error: could not compile `ownership` due to previous error如果你在其余语言中据说过术语 浅拷贝 （shallow copy）和 深拷贝 （deep copy），那么拷贝指针、长度和容量而不拷贝数据可能听起来像浅拷贝。不过因为 Rust 同时使第一个变量有效了，这个操作被称为 挪动 （move），而不是浅拷贝。下面的例子能够解读为 s1 被 挪动 到了 s2 中。那么具体产生了什么，如图 4 所示。
图 4：s1 有效之后的内存体现
这样就解决了咱们的问题！因为只有 s2 是无效的，当其来到作用域，它就开释本人的内存，结束。
另外，这里还隐含了一个设计抉择：Rust 永远也不会主动创立数据的“深拷贝”。因而，任何 主动 的复制能够被认为对运行时性能影响较小。
2.4.2. 变量与数据交互的形式（二）：克隆
如果咱们 的确 须要深度复制 String 中堆上的数据，而不仅仅是栈上的数据，能够应用一个叫做 clone 的通用函数。第五章会探讨办法语法，不过因为办法在很多语言中是一个常见性能，所以之前你可能曾经见过了。
这是一个理论应用 clone 办法的例子：
let s1 = String::from("hello");
let s2 = s1.clone();
println!("s1 = {}, s2 = {}", s1, s2);
这段代码能失常运行，并且明确产生图 3 中行为，这里堆上的数据 的确 被复制了。
当呈现 clone 调用时，你晓得一些特定的代码被执行而且这些代码可能相当耗费资源。你很容易察觉到一些不寻常的事件正在产生。
2.4.3. 只在栈上的数据：拷贝
这里还有一个没有提到的小窍门。这些代码应用了整型并且是无效的，他们是示例 2 中的一部分：
let x = 5;
let y = x;
println!("x = {}, y = {}", x, y);但这段代码仿佛与咱们刚刚学到的内容相矛盾：没有调用 clone，不过 x 仍然无效且没有被挪动到 y 中。
起因是像整型这样的在编译时已知大小的类型被整个存储在栈上，所以拷贝其理论的值是疾速的。这意味着没有理由在创立变量 y 后使 x 有效。换句话说，这里没有深浅拷贝的区别，所以这里调用 clone 并不会与通常的浅拷贝有什么不同，咱们能够不必管它。
Rust 有一个叫做 Copy trait 的非凡注解，能够用在相似整型这样的存储在栈上的类型上。如果一个类型实现了 Copy trait，那么一个旧的变量在将其赋值给其余变量后依然可用。
Rust 不容许本身或其任何局部实现了 Drop trait 的类型应用 Copy trait。如果咱们对其值来到作用域时须要非凡解决的类型应用 Copy 注解，将会呈现一个编译时谬误。
那么哪些类型实现了 Copy trait 呢？你能够查看给定类型的文档来确认，不过作为一个通用的规定，任何一组简略标量值的组合都能够实现 Copy，任何不须要分配内存或某种模式资源的类型都能够实现 Copy。如下是一些 Copy 的类型：
•所有整数类型，比方 u32。
•布尔类型，bool，它的值是 true 和 false。
•所有浮点数类型，比方 f64。
•字符类型，char。
•元组，当且仅当其蕴含的类型也都实现 Copy 的时候。比方，(i32, i32) 实现了 Copy，但 (i32, String) 就没有。
2.5. 所有权与函数
将值传递给函数与给变量赋值的原理类似。向函数传递值可能会挪动或者复制，就像赋值语句一样。示例 3 应用正文展现变量何时进入和来到作用域：
文件名: src/main.rs
fn main() {let s = String::from("hello"); // s 进入作用域
takes_ownership(s); // s 的值挪动到函数里 ...
// ... 所以到这里不再无效
let x = 5; // x 进入作用域
makes_copy(x); // x 应该挪动函数里，// 但 i32 是 Copy 的，// 所以在前面可持续应用 x
} // 这里, x 先移出了作用域，而后是 s。但因为 s 的值已被移走，// 没有非凡之处
fn takes_ownership(some_string: String) { // some_string 进入作用域
println!("{}", some_string);
} // 这里，some_string 移出作用域并调用 `drop` 办法。// 占用的内存被开释
fn makes_copy(some_integer: i32) { // some_integer 进入作用域
println!("{}", some_integer);
} // 这里，some_integer 移出作用域。没有非凡之处示例 3：带有所有权和作用域正文的函数
当尝试在调用 takes_ownership 后应用 s 时，Rust 会抛出一个编译时谬误。这些动态查看使咱们免于犯错。试试在 main 函数中增加应用 s 和 x 的代码来看看哪里能应用他们，以及所有权规定会在哪里阻止咱们这么做。
2.6. 返回值与作用域
返回值也能够转移所有权。示例 4 展现了一个返回了某些值的示例，与示例 3 一样带有相似的正文。
文件名: src/main.rs
fn main() {let s1 = gives_ownership(); // gives_ownership 将返回值
// 转移给 s1
let s2 = String::from("hello"); // s2 进入作用域
let s3 = takes_and_gives_back(s2); // s2 被挪动到
// takes_and_gives_back 中,
// 它也将返回值移给 s3
} // 这里, s3 移出作用域并被抛弃。s2 也移出作用域，但已被移走，// 所以什么也不会产生。s1 来到作用域并被抛弃
fn gives_ownership() -> String { // gives_ownership 会将
// 返回值挪动给
// 调用它的函数
let some_string = String::from("yours"); // some_string 进入作用域.
some_string // 返回 some_string
// 并移出给调用的函数
//
}
// takes_and_gives_back 将传入字符串并返回该值
fn takes_and_gives_back(a_string: String) -> String { // a_string 进入作用域
//
a_string // 返回 a_string 并移出给调用的函数
}示例 4: 转移返回值的所有权
变量的所有权总是遵循雷同的模式：将值赋给另一个变量时挪动它。当持有堆中数据值的变量来到作用域时，其值将通过 drop 被清理掉，除非数据被挪动为另一个变量所有。
尽管这样是能够的，然而在每一个函数中都获取所有权并接着返回所有权有些啰嗦。如果咱们想要函数应用一个值但不获取所有权该怎么办呢？如果咱们还要接着应用它的话，每次都传进去再返回来就有点烦人了，除此之外，咱们也可能想返回函数体中产生的一些数据。
咱们能够应用元组来返回多个值，如示例 5 所示。
文件名: src/main.rs
fn main() {let s1 = String::from("hello");
let (s2, len) = calculate_length(s1);
println!("The length of'{}'is {}.", s2, len);
}
fn calculate_length(s: String) -> (String, usize) {let length = s.len(); // len() 返回字符串的长度
(s, length)
}示例 5: 返回参数的所有权
然而这未免有些形式主义，而且这种场景应该很常见。侥幸的是，Rust 对此提供了一个不必获取所有权就能够应用值的性能，叫做 援用（references）。
三. 援用与借用
示例 5 中的元组代码有这样一个问题：咱们必须将 String 返回给调用函数，以便在调用 calculate_length 后仍能应用 String，因为 String 被挪动到了 calculate_length 内。相同咱们能够提供一个 String 值的援用（reference）。援用（reference）像一个指针，因为它是一个地址，咱们能够由此拜访贮存于该地址的属于其余变量的数据。与指针不同，援用确保指向某个特定类型的有效值。
上面是如何定义并应用一个（新的）calculate_length 函数，它以一个对象的援用作为参数而不是获取值的所有权：
文件名: src/main.rs
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()
}首先，留神变量申明和函数返回值中的所有元组代码都隐没了。其次，留神咱们传递 &s1 给 calculate_length，同时在函数定义中，咱们获取 &String 而不是 String。这些 & 符号就是 援用，它们容许你应用值但不获取其所有权。图 5 展现了一张示意图。
图 5：&String s 指向 String s1 示意图
留神：与应用 & 援用相同的操作是 解援用（dereferencing），它应用解援用运算符，*。咱们将会在第八章遇到一些解援用运算符，并在第十五章具体探讨解援用。
认真看看这个函数调用：
let s1 = String::from("hello");
let len = calculate_length(&s1);&s1 语法让咱们创立一个 指向 值 s1 的援用，然而并不领有它。因为并不领有这个值，所以当援用停止使用时，它所指向的值也不会被抛弃。
同理，函数签名应用 & 来表明参数 s 的类型是一个援用。让咱们减少一些解释性的正文：
fn calculate_length(s: &String) -> usize { // s 是 String 的援用
s.len()} // 这里，s 来到了作用域。但因为它并不领有援用值的所有权，// 所以什么也不会产生变量 s 无效的作用域与函数参数的作用域一样，不过当 s 停止使用时并不抛弃援用指向的数据，因为 s 并没有所有权。当函数应用援用而不是理论值作为参数，无需返回值来交还所有权，因为就未曾领有所有权。
咱们将创立一个援用的行为称为 借用（borrowing）。正如现实生活中，如果一个人领有某样货色，你能够从他那里借来。当你应用结束，必须还回去。咱们并不领有它。
如果咱们尝试批改借用的变量呢？尝试示例 6 中的代码。剧透：这行不通！
文件名: src/main.rs
fn main() {let s = String::from("hello");
change(&s);
}
fn change(some_string: &String) {some_string.push_str(", world");
}示例 6：尝试批改借用的值
这里是谬误：
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` reference
--> src/main.rs:8:5
|
7 | fn change(some_string: &String) {
| ------- help: consider changing this to be a mutable reference: `&mut String`
8 | some_string.push_str(", world");
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable
For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` due to previous error正如变量默认是不可变的，援用也一样。（默认）不容许批改援用的值。
3.1. 可变援用
咱们通过一个小调整就能修复示例 6 代码中的谬误，容许咱们批改一个借用的值，这就是 可变援用（mutable reference）：
文件名: src/main.rs
fn main() {let mut s = String::from("hello");
change(&mut s);
}
fn change(some_string: &mut String) {some_string.push_str(", world");
}首先，咱们必须将 s 改为 mut。而后在调用 change 函数的中央创立一个可变援用 &mut s，并更新函数签名以承受一个可变援用 some_string: &mut String。这就十分分明地表明，change 函数将扭转它所借用的值。
可变援用有一个很大的限度：如果你有一个对该变量的可变援用，你就不能再创立对该变量的援用。这些尝试创立两个 s 的可变援用的代码会失败：
文件名: src/main.rs
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{}, {}", r1, r2);谬误如下：
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
--> src/main.rs:5:14
|
4 | let r1 = &mut s;
| ------ first mutable borrow occurs here
5 | let r2 = &mut s;
| ^^^^^^ second mutable borrow occurs here
6 |
7 | println!("{}, {}", r1, r2);
| -- first borrow later used here
For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` due to previous error这个报错说这段代码是有效的，因为咱们不能在同一时间屡次将 s 作为可变变量借用。第一个可变的借入在 r1 中，并且必须继续到在 println！ 中应用它，然而在那个可变援用的创立和它的应用之间，咱们又尝试在 r2 中创立另一个可变援用，该援用借用与 r1 雷同的数据。
这一限度以一种十分小心谨慎的形式容许可变性，避免同一时间对同一数据存在多个可变援用。新 Rustacean 们常常难以适应这一点，因为大部分语言中变量任何时候都是可变的。这个限度的益处是 Rust 能够在编译时就防止数据竞争。数据竞争（data race）相似于竞态条件，它可由这三个行为造成：
•两个或更多指针同时拜访同一数据。
•至多有一个指针被用来写入数据。
•没有同步数据拜访的机制。
数据竞争会导致未定义行为，难以在运行时追踪，并且难以诊断和修复；Rust 防止了这种状况的产生，因为它甚至不会编译存在数据竞争的代码！
判若两人，能够应用大括号来创立一个新的作用域，以容许领有多个可变援用，只是不能 同时 领有：
let mut s = String::from("hello");
{let r1 = &mut s;} // r1 在这里来到了作用域，所以咱们齐全能够创立一个新的援用
let r2 = &mut s;Rust 在同时应用可变与不可变援用时也采纳的相似的规定。这些代码会导致一个谬误：
let mut s = String::from("hello");
let r1 = &s; // 没问题
let r2 = &s; // 没问题
let r3 = &mut s; // 大问题
println!("{}, {}, and {}", r1, r2, r3);谬误如下：
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
--> src/main.rs:6:14
|
4 | let r1 = &s; // no problem
| -- immutable borrow occurs here
5 | let r2 = &s; // no problem
6 | let r3 = &mut s; // BIG PROBLEM
| ^^^^^^ mutable borrow occurs here
7 |
8 | println!("{}, {}, and {}", r1, r2, r3);
| -- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` due to previous error谬误提醒咱们也不能在领有不可变援用的同时领有可变援用。
不可变援用的用户可不心愿在他们的眼皮底下值就被意外的扭转了！然而，多个不可变援用是能够的，因为没有哪个只能读取数据的人有能力影响其他人读取到的数据。
留神一个援用的作用域从申明的中央开始始终继续到最初一次应用为止。例如，因为最初一次应用不可变援用（println!)，产生在申明可变援用之前，所以如下代码是能够编译的：
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 的作用域在 println! 最初一次应用之后完结，这也是创立可变援用 r3 的中央。它们的作用域没有重叠，所以代码是能够编译的。编译器在作用域完结之前判断不再应用的援用的能力被称为 非词法作用域生命周期（Non-Lexical Lifetimes，简称 NLL）。
只管这些谬误有时使人丧气，但请牢记这是 Rust 编译器在提前指出一个潜在的 bug（在编译时而不是在运行时）并精准显示问题所在。这样你就不用去跟踪为何数据并不是你设想中的那样。
3.2. 悬垂援用（Dangling References）
在具备指针的语言中，很容易通过开释内存时保留指向它的指针而谬误地生成一个 悬垂指针（dangling pointer），所谓悬垂指针是其指向的内存可能曾经被调配给其它持有者。相比之下，在 Rust 中编译器确保援用永远也不会变成悬垂状态：当你领有一些数据的援用，编译器确保数据不会在其援用之前来到作用域。
让咱们尝试创立一个悬垂援用，Rust 会通过一个编译时谬误来防止：
文件名: src/main.rs
fn main() {let reference_to_nothing = dangle();
}
fn dangle() -> &String {let s = String::from("hello");
&s
}这里是谬误：
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0106]: missing lifetime specifier
--> src/main.rs:5:16
|
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 {
| ~~~~~~~~
For more information about this error, try `rustc --explain E0106`.
error: could not compile `ownership` due to previous error错误信息援用了一个咱们还未介绍的性能：生命周期（lifetimes）。第十章会具体介绍生命周期。不过，如果你不理睬生命周期局部，错误信息中的确蕴含了为什么这段代码有问题的要害信息：
this function's return type contains a borrowed value, but there is no value
for it to be borrowed from让咱们认真看看咱们的 dangle 代码的每一步到底产生了什么：
文件名: src/main.rs
fn dangle() -> &String { // dangle 返回一个字符串的援用
let s = String::from("hello"); // s 是一个新字符串
&s // 返回字符串 s 的援用
} // 这里 s 来到作用域并被抛弃。其内存被开释。// 危险！因为 s 是在 dangle 函数内创立的，当 dangle 的代码执行结束后，s 将被开释。不过咱们尝试返回它的援用。这意味着这个援用会指向一个有效的 String，这可不对！Rust 不会容许咱们这么做。
这里的解决办法是间接返回 String：
fn no_dangle() -> String {let s = String::from("hello");
s
}这样就没有任何谬误了。所有权被挪动进来，所以没有值被开释。
3.3. 援用的规定
让咱们概括一下之前对援用的探讨：
•在任意给定工夫，要么 只能有一个可变援用，要么 只能有多个不可变援用。
•援用必须总是无效的。
接下来，咱们来看看另一种不同类型的援用：slice。
四.Slice 类型
slice 容许你援用汇合中一段间断的元素序列，而不必援用整个汇合。slice 是一类援用，所以它没有所有权。
这里有一个编程小习题：编写一个函数，该函数接管一个用空格分隔单词的字符串，并返回在该字符串中找到的第一个单词。如果函数在该字符串中并未找到空格，则整个字符串就是一个单词，所以应该返回整个字符串。
让咱们斟酌下如何不必 slice 编写这个函数的签名，来了解 slice 能解决的问题：
fn first_word(s: &String) -> ?first_word 函数有一个参数 &String。因为咱们不须要所有权，所以这没有问题。不过应该返回什么呢？咱们并没有一个真正获取 局部 字符串的方法。不过，咱们能够返回单词结尾的索引，结尾由一个空格示意。试试如示例 7 中的代码。
文件名: src/main.rs
fn first_word(s: &String) -> usize {let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {return i;}
}
s.len()}示例 7：first_word 函数返回 String 参数的一个字节索引值
因为须要一一元素的查看 String 中的值是否为空格，须要用 as_bytes 办法将 String 转化为字节数组：
let bytes = s.as_bytes();接下来，应用 iter 办法在字节数组上创立一个迭代器：
for (i, &item) in bytes.iter().enumerate() {上述代码中，iter 办法返回汇合中的每一个元素，而 enumerate 包装了 iter 的后果，将这些元素作为元组的一部分来返回。enumerate 返回的元组中，第一个元素是索引，第二个元素是汇合中元素的援用。这比咱们本人计算索引要不便一些。
因为 enumerate 办法返回一个元组，咱们能够应用模式来解构，咱们将在第六章中进一步探讨无关模式的问题。所以在 for 循环中，咱们指定了一个模式，其中元组中的 i 是索引而元组中的 &item 是单个字节。因为咱们从 .iter().enumerate() 中获取了汇合元素的援用，所以模式中应用了 &。
在 for 循环中，咱们通过字节的字面值语法来寻找代表空格的字节。如果找到了一个空格，返回它的地位。否则，应用 s.len() 返回字符串的长度：
if item == b' ' {return i;}
}
s.len()当初有了一个找到字符串中第一个单词结尾索引的办法，不过这有一个问题。咱们返回了一个独立的 usize，不过它只在 &String 的上下文中才是一个有意义的数字。换句话说，因为它是一个与 String 相拆散的值，无奈保障未来它依然无效。考虑一下示例 8 中应用了示例 7 中 first_word 函数的程序。
文件名: src/main.rs
fn main() {let mut s = String::from("hello world");
let word = first_word(&s); // word 的值为 5
s.clear(); // 这清空了字符串，使其等于 ""
// word 在此处的值依然是 5，// 然而没有更多的字符串让咱们能够无效地利用数值 5。word 的值当初齐全有效！}示例 8：存储 first_word 函数调用的返回值并接着扭转 String 的内容
这个程序编译时没有任何谬误，而且在调用 s.clear() 之后应用 word 也不会出错。因为 word 与 s 状态齐全没有分割，所以 word 依然蕴含值 5。能够尝试用值 5 来提取变量 s 的第一个单词，不过这是有 bug 的，因为在咱们将 5 保留到 word 之后 s 的内容曾经扭转。
咱们不得不时刻放心 word 的索引与 s 中的数据不再同步，这很啰嗦且易出错！如果编写这么一个 second_word 函数的话，治理索引这件事将更加容易出问题。它的签名看起来像这样：
fn second_word(s: &String) -> (usize, usize) {当初咱们要跟踪一个开始索引 和 一个结尾索引，同时有了更多从数据的某个特定状态计算而来的值，但都齐全没有与这个状态相关联。当初有三个飘忽不定的不相干变量须要放弃同步。
侥幸的是，Rust 为这个问题提供了一个解决办法：字符串 slice。
4.1. 字符串 slice
字符串 slice（string slice）是 String 中一部分值的援用，它看起来像这样：
let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];不同于整个 String 的援用，hello 是一个局部 String 的援用，由一个额定的 [0..5] 局部指定。能够应用一个由中括号中的 [starting_index..ending_index] 指定的 range 创立一个 slice，其中 starting_index 是 slice 的第一个地位，ending_index 则是 slice 最初一个地位的后一个值。在其外部，slice 的数据结构存储了 slice 的开始地位和长度，长度对应于 ending_index 减去 starting_index 的值。所以对于 let world = &s[6..11]; 的状况，world 将是一个蕴含指向 s 索引 6 的指针和长度值 5 的 slice。
图 6 展现了一个图例。
图 6：援用了局部 String 的字符串 slice
对于 Rust 的 .. range 语法，如果想要从索引 0 开始，能够不写两个点号之前的值。换句话说，如下两个语句是雷同的：
let s = String::from("hello");
let slice = &s[0..2];
let slice = &s[..2];依此类推，如果 slice 蕴含 String 的最初一个字节，也能够舍弃尾部的数字。这意味着如下也是雷同的：
let s = String::from("hello");
let len = s.len();
let slice = &s[3..len];
let slice = &s[3..];也能够同时舍弃这两个值来获取整个字符串的 slice。所以如下亦是雷同的：
let s = String::from("hello");
let len = s.len();
let slice = &s[0..len];
let slice = &s[..];留神：字符串 slice range 的索引必须位于无效的 UTF-8 字符边界内，如果尝试从一个多字节字符的两头地位创立字符串 slice，则程序将会因谬误而退出。出于介绍字符串 slice 的目标，本局部假如只应用 ASCII 字符集；第八章的“应用字符串存储 UTF-8 编码的文本”局部会更加全面的探讨 UTF-8 解决问题。
在记住所有这些常识后，让咱们重写 first_word 来返回一个 slice。“字符串 slice”的类型申明写作 &str：
文件名: src/main.rs
fn first_word(s: &String) -> &str {let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {return &s[0..i];
}
}
&s[..]
}咱们应用跟示例 7 雷同的形式获取单词结尾的索引，通过寻找第一个呈现的空格。当找到一个空格，咱们返回一个字符串 slice，它应用字符串的开始和空格的索引作为开始和完结的索引。
当初当调用 first_word 时，会返回与底层数据关联的单个值。这个值由一个 slice 开始地位的援用和 slice 中元素的数量组成。
second_word 函数也能够改为返回一个 slice：
fn second_word(s: &String) -> &str {当初咱们有了一个不易混同且直观的 API 了，因为编译器会确保指向 String 的援用继续无效。还记得示例 8 程序中，那个当咱们获取第一个单词结尾的索引后，接着就革除了字符串导致索引就有效的 bug 吗？那些代码在逻辑上是不正确的，但却没有显示任何间接的谬误。问题会在之后尝试对空字符串应用第一个单词的索引时呈现。slice 就不可能呈现这种 bug 并让咱们更早的晓得出问题了。应用 slice 版本的 first_word 会抛出一个编译时谬误：
文件名: src/main.rs
fn main() {let mut s = String::from("hello world");
let word = first_word(&s);
s.clear(); // 谬误!
println!("the first word is: {}", word);
}这里是编译谬误：
$ cargo run
Compiling ownership v0.1.0 (file:///projects/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
--> src/main.rs:18:5
|
16 | let word = first_word(&s);
| -- immutable borrow occurs here
17 |
18 | s.clear(); // error!
| ^^^^^^^^^ mutable borrow occurs here
19 |
20 | println!("the first word is: {}", word);
| ---- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` due to previous error回顾一下借用规定，当领有某值的不可变援用时，就不能再获取一个可变援用。因为 clear 须要清空 String，它尝试获取一个可变援用。在调用 clear 之后的 println! 应用了 word 中的援用，所以这个不可变的援用在此时必须依然无效。Rust 不容许 clear 中的可变援用和 word 中的不可变援用同时存在，因而编译失败。Rust 不仅使得咱们的 API 简略易用，也在编译时就打消了一整类的谬误！
4.1.1. 字符串字面值就是 slice
还记得咱们讲到过字符串字面值被贮存在二进制文件中吗？当初晓得 slice 了，咱们就能够正确地了解字符串字面值了：
let s = "Hello, world!";这里 s 的类型是 &str：它是一个指向二进制程序特定地位的 slice。这也就是为什么字符串字面值是不可变的；&str 是一个不可变援用。
4.1.2. 字符串 slice 作为参数
在晓得了可能获取字面值和 String 的 slice 后，咱们对 first_word 做了改良，这是它的签名：
fn first_word(s: &String) -> &str {而更有教训的 Rustacean 会编写出示例 9 中的签名，因为它使得能够对 &String 值和 &str 值应用雷同的函数：
fn first_word(s: &str) -> &str {示例 9: 通过将 s 参数的类型改为字符串 slice 来改良 first_word 函数
如果有一个字符串 slice，能够间接传递它。如果有一个 String，则能够传递整个 String 的 slice 或对 String 的援用。定义一个获取字符串 slice 而不是 String 援用的函数使得咱们的 API 更加通用并且不会失落任何性能：
文件名: src/main.rs
fn main() {let my_string = String::from("hello world");
// `first_word` 实用于 `String`（的 slice），整体或全副
let word = first_word(&my_string[0..6]);
let word = first_word(&my_string[..]);
// `first_word` 也实用于 `String` 的援用，// 这等价于整个 `String` 的 slice
let word = first_word(&my_string);
let my_string_literal = "hello world";
// `first_word` 实用于字符串字面值，整体或全副
let word = first_word(&my_string_literal[0..6]);
let word = first_word(&my_string_literal[..]);
// 因为字符串字面值曾经 ** 是 ** 字符串 slice 了，// 这也是实用的，无需 slice 语法！let word = first_word(my_string_literal);
}4.2. 其余类型的 slice
字符串 slice，正如你设想的那样，是针对字符串的。不过也有更通用的 slice 类型。考虑一下这个数组：
let a = [1, 2, 3, 4, 5];就跟咱们想要获取字符串的一部分那样，咱们也会想要援用数组的一部分。咱们能够这样做：
let a = [1, 2, 3, 4, 5];
let slice = &a[1..3];
assert_eq!(slice, &[2, 3]);这个 slice 的类型是 &[i32]。它跟字符串 slice 的工作形式一样，通过存储第一个汇合元素的援用和一个汇合总长度。你能够对其余所有汇合应用这类 slice。第八章讲到 vector 时会具体探讨这些汇合。
五. 总结
所有权、借用和 slice 这些概念让 Rust 程序在编译时确保内存平安。Rust 语言提供了跟其余零碎编程语言雷同的形式来管制你应用的内存，但领有数据所有者在来到作用域后主动革除其数据的性能意味着你毋庸额定编写和调试相干的控制代码。Rust 自带的这些机制尽管就义了一些灵活性，但也从根本上保障了内存的平安，只有遵循这些规定，就能轻松写出平安的代码。
六. 援用
[1] Rust 教程 | 菜鸟教程 (runoob.com)
[2] 除了 RUST，还有国产架构：Linux6.1 内核稳定版首公布！_中文科技资讯 提供快捷产业新资讯 翻新驱动商业 (citnews.com.cn)
[3] crates.io: Rust Package Registry
[4] 字节跳动在 Rust 微服务方向的摸索和实际 | QCon_代码_问题_时候 (sohu.com)
[5] Rust 程序设计语言 – Rust 程序设计语言 简体中文版 (kaisery.github.io)
