The Rust Programming Language
Rust 编程语言

教程演示🔗

Go from zero Rust knowledge to being able to build your own complete Rust programs! You’ll learn the foundations of Rust, what makes it so performant when to choose to use it for your projects. You’ll use Rust’s built-in data types and standard libraries, add-in packages from Rust’s package ecosystem, and dive into Rust-specific concepts like ownership, borrowing, and lifetimes. Along the way, you’ll pick up some low-level programming concepts that can help you better understand the other languages you use.
从零 Rust 知识到能够构建自己的完整 Rust 程序！您将了解 Rust 的基础知识，以及是什么让它在选择将其用于您的项目时如此高效。您将使用 Rust 的内置数据类型和标准库、来自 Rust 包生态系统的插件包，并深入了解特定于 Rust 的概念，例如所有权、借用和生命周期。在此过程中，您将学习一些低级编程概念，这些概念可以帮助您更好地理解您使用的其他语言。

This course and others like it are available as part of our Frontend Masters video subscription.
本课程和其他类似课程可作为我们的前端大师视频订阅的一部分提供。

Table of Contents 目录

Introduction 介绍

00:00:00 – 00:13:45
Introduction 介绍
Richard Feldman introduces the course by discussing what Rust is made for, various companies that use Rust, and the benefits and drawbacks of using Rust as a programming language. An overview of what will be covered in this course and a student’s question regarding what makes a slow compiler is also provided in this segment.
Richard Feldman 通过讨论 Rust 的用途、使用 Rust 的各种公司以及使用 Rust 作为编程语言的优点和缺点来介绍该课程。本部分还概述了本课程将涵盖的内容，以及学生关于是什么导致了缓慢编译器的问题。

Primitives 原

00:13:46 – 00:16:54
Strings 字符串
Richard discusses string interpolation in Rust including how to print and return string variables to the terminal using println, format, and panic. The panic command is only at the end of a program used when the program is finished running or crashes to print a message to terminal.
Richard 讨论了 Rust 中的字符串插值，包括如何使用 println、format 和 panic 打印字符串变量并将其返回到终端。panic 命令仅在程序完成运行或崩溃以将消息打印到终端时使用的程序末尾。

00:16:55 – 00:21:27
Floats & Mutability 浮动和可变性
Richard briefly discusses that floats in Rust are binary and setting a variable using let means both const and immutable. The keyword mut can be added to make a variable mutable.
Richard 简要讨论了 Rust 中的浮点数是二进制的，使用 let 设置变量意味着 const 和 immutable。可以添加关键字 mut 以使变量可变。

00:21:28 – 00:25:00
Rust Q&A Rust 问答
Richard answers student’s questions regarding what benefits there are having macros over functions, if there are performance difference between macros and functions, what the point of immutable variables is, and what it means that Rust is a static language.
Richard 回答了学生的问题，包括宏相对于函数有什么好处，宏和函数之间是否存在性能差异，不可变变量的意义是什么，以及 Rust 是一种静态语言意味着什么。

00:25:01 – 00:29:56
Numeric Types & Type Annotations
数值类型和类型注释
Richard demonstrates that numeric types cannot be changed to a different variable type and type annotations to be explicit of a variables type. Rust has type inference that will automatically assign a type to a variable and, if it cannot infer a type, the compiler will ask for the type annotation. A student’s question regarding if it’s possible to change a variable type on the fly is also covered in this segment.
Richard 演示了数值类型不能更改为不同的变量类型，并且类型注释不能显式为变量类型。Rust 具有类型推断功能，它会自动将类型分配给变量，如果它无法推断类型，编译器将要求提供类型注释。本部分还涵盖了学生关于是否可以即时更改变量类型的问题。

00:29:57 – 00:41:20
Integers 整数
Richard discusses the different sizes of float sizes including f64 and f32, the different types of integers, integer division, integer sizes, and signed versus unsigned integers. Integers do not have decimals and can be only whole numbers and negative numbers. Students question regarding what Rust’s compiler would choose to do with four u8 integers also covered in this segment.
Richard 讨论了浮点大小的不同大小，包括 f64 和 f32、不同类型的整数、整数除法、整数大小以及有符号与无符号整数。整数没有小数，只能是整数和负数。学生们质疑 Rust 的编译器会选择如何处理本节中也涉及的四个 u8 整数。

00:41:21 – 00:50:10
Booleans, Conditionals, Statements, and Expressions
布尔值、条件、语句和表达式
Richard demonstrates booleans in Rust, the syntax of conditionals, discusses that and expression in Rust is something that evaluates to a value, that a statement does not evaluate to a value, and provides multiple examples for each. The Rust compiler allows the convenience of not using the return keyword only on functions and else if statements ending on an expression.
Richard 演示了 Rust 中的布尔值，条件语句的语法，讨论了这一点，Rust 中的表达式是计算结果为值的东西，语句不计算值为值，并为每个语句提供了多个示例。Rust 编译器允许不仅在函数上使用 return 关键字，否则 if 语句以表达式结尾。

00:50:11 – 00:52:49
Statements and Expressions Q&A
语句和表达式 Q&A
Richard answers student’s questions regarding if the last expression is the return, if a function contains more than one expression can it also be automatically returned by the compiler, and if early returns need to be specified. Student’s questions regarding if the type is taken into account in comparisons, if variables of conditional statements if they can be passed around in the string interpolation, and if auto returns can be used for nullish conversion are also covered in this segment.
理查德回答了学生的问题，包括最后一个表达式是否是返回值，如果一个函数包含多个表达式，编译器也可以自动返回该表达式，以及是否需要指定早期返回值。本部分还涵盖了学生关于在比较中是否考虑类型、条件语句的变量是否可以在字符串插值中传递以及自动返回是否可以用于无效转换的问题。

00:52:50 – 00:59:12
Primitives Recap and Q&A 基元回顾和问答
Richard provides a brief overview of information covered in the first section of the course and opens for student questions. Student questions regarding the difference between traits and macros in Rust, if a return type can be inferred, how to check for libraries that Rust has, and if there are ternary operators are covered in this segment. Additional questions covered include if Rust is compiled into bit code or if it’s generated directly into machine code, can binary be cross compiled, if there are queue and stack collections, if a new I64 is created when using something like y as I64, are monoids and monads used in Rust, and if there is any built in crypto.
理查德简要概述了课程第一部分所涵盖的信息，并回答了学生的问题。关于 Rust 中特征和宏之间的区别、是否可以推断返回类型、如何检查 Rust 拥有的库以及是否有三元运算符的学生问题都包含在这一部分中。涵盖的其他问题包括 Rust 是否被编译成位代码或是否直接生成为机器代码，二进制是否可以交叉编译，是否有队列和堆栈集合，当使用 y 作为 I64 时是否创建了新的 I64，Rust 中是否使用了 monoid 和 monads，以及是否有任何内置的加密。

00:59:13 – 01:02:25
Primitives Exercise 基元练习
Students are instructed to compute population by converting numeric types, compute buildings per person, and print buildings per person to the terminal.
指导学生通过转换数值类型、计算人均建筑物以及将人均建筑物打印到终端来计算人口。

01:02:26 – 01:05:29
Primitives Solution 基元解决方案
Richard live codes the solution to the Primitives exercise. Student questions regarding if there are rules for function order in a single file and how cargo know that it’s source is main.rs are also covered in this segment.
理查德实时编写了原始练习的解决方案。本部分还涵盖了有关单个文件中是否有功能顺序规则以及 cargo 如何知道其来源 main.rs 的学生问题。

Collections 收集

01:05:30 – 01:09:53
Tuples 元组
Richard discusses how to define a tuple in Rust, set the values in a tuple to a variable, mutate tuples, and explains what a unit tuple is. Values in a tuple do not have to be the same type and can be set individually or by using destructuring syntax.
Richard 讨论了如何在 Rust 中定义元组，将元组中的值设置为变量，改变元组，并解释什么是单位元组。元组中的值不必是同一类型，可以单独设置，也可以使用解构语法进行设置。

01:09:54 – 01:14:41
Structs 结构
Richard demonstrates how to define structs in Rust, destructure a struct, ignore values in a struct, and demonstrates how to define mutable structs. Student’s questions regarding what point is being mutated in the example, if the order of the struct matters, and if nested structs can be made are also covered in this segment.
Richard 演示了如何在 Rust 中定义结构体、解构结构体、忽略结构体中的值，并演示了如何定义可变结构体。本部分还涵盖了学生关于示例中哪个点被突变的问题，结构的顺序是否重要，以及是否可以创建嵌套结构。

01:14:42 – 01:19:43
Arrays 阵 列
Richard discusses how to define an array in Rust, how to access values in an array, how to redefine values, and how to iterate over an array. Arrays in must all have the same type and a hardcoded length at compile time. A brief comparison of arrays and tuples is also discussed in this segment.
Richard 讨论了如何在 Rust 中定义数组，如何访问数组中的值，如何重新定义值，以及如何遍历数组。中的数组在编译时必须具有相同的类型和硬编码长度。本部分还讨论了数组和元组的简要比较。

01:19:44 – 01:27:30
Memory 记忆
Richard discusses the concept of memory being interpreted as a u8 array or a u16 array, how the order of a struct effects the values in memory, and the resulting overhead of arrays, tuples, and stucts.
Richard 讨论了将内存解释为 u8 数组或 u16 数组的概念、结构的顺序如何影响内存中的值，以及由此产生的数组、元组和 stuct 的开销。

01:27:31 – 01:31:15
Collections Recap and Q&A
馆藏回顾和问答
Richard provides a brief overview of the collection section in part 2 including tuples, structs, arrays, and memory. Students questions regarding if functions can be put in a struct, what kind of data iterable structure can be put in different types, if it’s possible to make more dynamic arrays, and if structs labels or values can be iterated upon are also covered in this segment.
Richard 简要概述了第 2 部分中的集合部分，包括元组、结构、数组和内存。本部分还涵盖了学生关于是否可以将函数放入结构中、可以将哪种数据可迭代结构放入不同类型的结构、是否可以创建更多动态数组以及是否可以迭代结构标签或值的问题。

01:31:16 – 01:33:54
Collections Exercise 收款练习
Students are instructed to add a field to is_costal:bool, return a City described as non-coastal based on a boolean, call a new city, print the description of rustville using string interpolation.
指导学生在 is_costal：bool 中添加一个字段，返回一个基于布尔值描述为非沿海的城市，调用一个新城市，使用字符串插值打印 rustville 的描述。

01:33:55 – 01:36:37
Collections Solution 收款解决方案
Richard live codes the solution to the Collections exercise.
理查德对集合练习的解决方案进行了实时编码。

Pattern Matching 模式匹配

01:36:38 – 01:44:28
Enums & Pattern Matching 枚举和模式匹配
Richard demonstrates how to define enums in Rust, set payloads for variants, obtain values using pattern matching, and use pattern matching as an if statement. Rust has no concept of null or undefined, therefore, if pattern matching is used like an if statement every variant must be covered or a compiler error will be thrown.
Richard 演示了如何在 Rust 中定义枚举、设置变体的有效负载、使用模式匹配获取值以及使用模式匹配作为 if 语句。Rust 没有 null 或 undefined 的概念，因此，如果像 if 语句一样使用模式匹配，则必须覆盖每个变体，否则将抛出编译器错误。

01:44:29 – 01:49:24
Methods 方法
Richard discusses how to define methods using the imple keyword and how to use self and Self to infer the impl type. Methods are similar to functions in that they’re declared with the fn keyword and a name, they can take parameters and a return, and they contain code that is run when they’re called.
Richard 讨论了如何使用 imple 关键字定义方法，以及如何使用 self 和 Self 来推断 impl 类型。方法与函数类似，因为它们是使用 fn 关键字和名称声明的，它们可以接受参数和返回值，并且它们包含在调用它们时运行的代码。

01:49:25 – 01:54:24
Type Parameters 类型参数
Richard discusses type parameters in Rust, option, and result. Option can be used to avoid errors if the value being altered the function could be nothing or null, while result is used for an operation that might fail.
Richard 讨论了 Rust 中的类型参数、option 和 result。如果更改的值，则 option 可用于避免错误，函数可能为 nothing 或 null，而 result 用于可能失败的操作。

01:54:25 – 01:58:44
Pattern Matching Recap and Q&A
模式匹配回顾和问答
Richard provides a brief review of enums, pattern matching, methods, type parameters and answers student questions. Student questions regarding what would happen with duplicate matches using pattern matching, if default values can be set in pattern matching, and if there is a way to add additional methods after an impl has been created are covered in this segment.
Richard 简要回顾了枚举、模式匹配、方法、类型参数，并回答了学生的问题。本部分涵盖了有关使用模式匹配进行重复匹配会发生什么、是否可以在模式匹配中设置默认值以及是否有办法在创建 impl 后添加其他方法的学生问题。

01:58:45 – 02:01:33
Pattern Matching Exercise
模式匹配练习
Students are instructed to handle the other CitySize variants individually and use City::new() to create a Metropolis-sized city.
指导学生单独处理其他 CitySize 变体，并使用 City：：new（） 创建一个大都市大小的城市。

02:01:34 – 02:07:26
Pattern Matching Solution
模式匹配解决方案
Richard live codes the solution to the Pattern Matching exercise. Student questions regarding how to create a custom resident count and how to encode values rather than types in the enum varience are also covered in this segment.
理查德实时编写了模式匹配练习的解决方案。本部分还涵盖了有关如何创建自定义常驻计数以及如何对枚举方差中的值而不是类型进行编码的学生问题。

Vectors 向量

02:07:27 – 02:14:14
Vectors 向量
Richard demonstrates how to define a vector or Vec in Rust, increase the vector size, return the length of a vector, usize, and the difference between arrays and vectors. Vectors must have a hard coded type, but do not need a hard coded length.
Richard 演示了如何在 Rust 中定义向量或 Vec、增加向量大小、返回向量的长度、usize 以及数组和向量之间的差异。向量必须具有硬编码类型，但不需要硬编码长度。

02:14:15 – 02:29:41
Stack Memory 堆栈内存
Richard discusses stack memory which used to store data for function arguments and return values. A walk through of what happens in memory when function arguments are passed and data is returned is also covered in this segment.
Richard 讨论了堆栈内存，它用于存储函数参数和返回值的数据。本部分还介绍了传递函数参数并返回数据时内存中发生的情况。

02:29:42 – 02:38:22
The Heap 堆
Richard discusses the function of the heap, gives a walk through of how the heap allocates space, and the differences between the stack and heap.The heap is memory space that is used as seperate storage for the stack. I follows different rules then the stack which allows for more flexibility when handling memory allotment.
Richard 讨论了堆的功能，介绍了堆如何分配空间，以及堆栈和堆之间的差异。堆是用作堆栈的单独存储的内存空间。我遵循与堆栈不同的规则，这在处理内存分配时具有更大的灵活性。

02:38:23 – 02:44:36
Vectors Recap and Q&A 矢量回顾和问答
Richard provides a review of vectors, usize, stack memory, heap memory, and opens for student questions. Student questions regarding if usize is a pointer, if there is a macro that instanciates and sets capacity at the same time without needing to push, is capacity up to Rust, what to do if the size of a list is unknown, and if it’s better to use a linked list data structure are covered in this segment.
Richard 回顾了向量、usize、堆栈内存、堆内存，并回答了学生的问题。关于usize是否是一个指针，是否有一个宏可以同时实例化和设置容量而不需要推送，容量是否达到Rust，如果列表的大小未知该怎么办，以及使用链表数据结构是否更好，这部分涵盖了学生的问题。

02:44:37 – 02:45:59
Vectors Exercise 向量练习
Students are instructed to use .pop() to remove the last city, use .push() to move last_city back into city_names, and print each of the city names.
指导学生使用 .pop（） 删除最后一个城市，使用 .push（） 将last_city移回city_names，并打印每个城市名称。

02:46:00 – 02:50:36
Vectors Solution 载体解决方案
Richard live codes the solution to the Vectors exercise. A student’s question regarding why match is needed is also covered in this segment.
理查德实时编码了 Vectors 练习的解决方案。这一部分还涵盖了学生关于为什么需要匹配的问题。

Ownership 所有权

02:50:37 – 02:54:07
Heap Bookkeeping 堆簿记
Richard briefly provides an overview of part 5 of the course and discusses the process of the alloc function. The alloc function, when called, will take unused heap bytes and mark them as being in-use for later reference.
Richard 简要概述了本课程的第 5 部分，并讨论了 alloc 函数的过程。调用 alloc 函数时，将获取未使用的堆字节，并将它们标记为正在使用中以供以后参考。

02:54:08 – 03:07:22
Manual Memory Management 手动内存管理
Richard discusses how to decide when and where it is safe to mark space on the heap as no longer in use, demonstrates where dealloc could be called in C, and the possible bugs that can be caused by manual memory managment. How garbage collection in other languages such as JavaScript, Python, Ruby, and Java is also discussed in this segment.
Richard 讨论了如何确定何时何地安全地将堆上的空间标记为不再使用，演示了在 C 语言中可以调用 dealloc 的位置，以及手动内存管理可能导致的错误。本部分还讨论了其他语言（如 JavaScript、Python、Ruby 和 Java）中的垃圾回收。

03:07:23 – 03:11:50
Rust Memory Management Rust 内存管理
Richard discusses how automatic memory management works in Rust, briefly mentions edge cases where automatic deallocation could error, and how functions can be rewritten to safely deallocate memory sooner. Rust will automatically insert the dealloc function when the data is no longer in scope and it’s no longer being used.
Richard 讨论了 Rust 中的自动内存管理是如何工作的，简要提到了自动释放可能出错的边缘情况，以及如何重写函数以更快地安全地释放内存。当数据不再在范围内并且不再使用时，Rust 会自动插入 dealloc 函数。

03:11:51 – 03:22:37
Ownership 所有权
Richard discusses how Rust assigns an owner when it makes an allocation, how return transfers owners, the use-after-move compiler error, and .clone(). A student questions regarding if it’s enough to just return the variable is also covered in this segment.
Richard 讨论了 Rust 在进行分配时如何分配所有者、return 如何转移所有者、使用后移动编译器错误和 .clone（）。本部分还涵盖了学生关于仅返回变量是否足够的问题。

03:22:38 – 03:26:01
Ownership Recap & Memory Exercise
所有权回顾和记忆练习
Richard provides a brief overview of manual memory, automatic memory, ownership, and cloning. Students are then instructed to solve a compiler error, call product(), call average(), and use .clone() or change the function to return a tuple.
Richard 简要概述了手动内存、自动内存、所有权和克隆。然后指导学生解决编译器错误、调用 product（）、调用 average（） 并使用 .clone（） 或更改函数以返回元组。

03:26:02 – 03:32:53
Memory Solution 内存解决方案
Richard live codes the solution to the Memory exercise. Student questions regarding what sum.0 does, if using an array instead of a vector would bypass the process, and why can you reuse numbers instead of changing it to numbers2 and numbers3 are also covered in this segment.
理查德现场编写了记忆练习的解决方案。本部分还涵盖了学生关于 sum.0 的作用、使用数组而不是向量是否会绕过该过程以及为什么可以重用数字而不是将其更改为 numbers2 和 numbers3 的问题。

Borrowing 借贷

03:32:54 – 03:37:53
References & Borrowing 参考资料和借用
Richard demonstrates how to define a reference, which allows access to data without assigning ownership, and a borrow, which temporarily gives a function access to a variable. The borrow checker cannot be turned off in Rust which will throw errors unless references or borrowing is used.
Richard 演示了如何定义引用，它允许在不分配所有权的情况下访问数据，以及借用，它临时授予函数对变量的访问权限。在 Rust 中无法关闭借用检查器，除非使用引用或借用，否则会抛出错误。

03:37:54 – 03:44:33
Mutable References 可变引用
Richard discusses how to designate references as mutable, an example using clear(), and the differences between mutable and immutable references when using let mut. A mutable reference will not take ownership of the data, but will be allowed to mutate the data.
Richard 讨论了如何将引用指定为可变引用，使用 clear（） 的示例，以及使用 let mut 时可变引用和不可变引用之间的区别。可变引用不会获取数据的所有权，但允许更改数据。

03:44:34 – 03:50:14
Slices 片
Richard discusses the reference type slice, vector slices, and string slices. A slice will reference a section of pre-exisiting data on the heap without copying or cloning. A brief review of borrowing, mutable references, slices, and string slices is also covered in this segment.
Richard 讨论了引用类型切片、向量切片和字符串切片。切片将引用堆上预先存在的数据的一部分，而无需复制或克隆。本部分还简要回顾了借用、可变引用、切片和字符串切片。

03:50:15 – 03:51:53
Borrowing Exercise 借阅活动
Students are instructed to use references, borrowing, and slices to solve the compiler error, call product(), call average(), and use .clone() or change the function to return a tuple.
指导学生使用引用、借用和切片来解决编译器错误，调用 product（）、调用 average（） 并使用 .clone（） 或更改函数以返回元组。

03:51:54 – 03:55:41
Borrowing Solution 借贷方案
Richard live codes the solution to the Borrowing exercise. A students question regarding what would happen if the slice was hard coded and the vector changed is also covered in this segment.
理查德实时编码了借款练习的解决方案。本部分还介绍了一个学生问题，即如果切片被硬编码并且向量发生了变化会发生什么。

Lifetimes 寿命

03:55:42 – 04:03:20
Lifetimes 寿命
Richard discusses how to use the concept of lifetimes to track what’s happening in Rust’s memory management model. A memory lifetime begins when it’s allocated and ends when it is deallocated.
Richard 讨论了如何使用生命周期的概念来跟踪 Rust 内存管理模型中发生的事情。内存生存期从分配时开始，到解除分配时结束。

04:03:21 – 04:11:25
Lifetime Annotations 生命周期注释
Richard demonstrates how to assign lifetime annotations to help keep track of when variables become out of scope. Lifetime annotations can be called anything, but must start with an apostrophe.
Richard 演示了如何分配生存期注释，以帮助跟踪变量何时超出范围。生存期注释可以称为任何内容，但必须以撇号开头。

04:11:26 – 04:17:29
Lifetime Elision 终身省略
Richard discusses that lifetime elision is when the compiler knows the lifetime of a variable and doesn’t require annotations. Student questions regarding why the compiler cannot extend a variable’s lifetime, why the function call in the example uses all_years and doesn’t reference all_years, and what naming conventions are recommended for lifetime annotations are covered in this segment.
Richard 认为，生存期省略是指编译器知道变量的生存期并且不需要注释。本部分涵盖了有关编译器为什么不能延长变量生存期、为什么示例中的函数调用使用 all_years 而不引用all_years以及为生存期注释推荐哪些命名约定的学生问题。

04:17:30 – 04:22:22
The Static Lifetime & Lifetimes Recap
静态生存期和生存期回顾
Richard discusses the static lifetime and provides a brief review of this segment including lifetimes, lifetime annotations, lifetime elison, and the static lifetime. Static lifetime is defined with an annotation of ‘static that notes the variable always exists in the program’s binary.
Richard 讨论了静态生存期，并简要回顾了这一部分，包括生存期、生存期注释、生存期 elison 和静态生存期。静态生存期是用“静态”的注释定义的，该注释指出变量始终存在于程序的二进制文件中。

04:22:23 – 04:24:04
Lifetimes Exercise 终生锻炼
Students are instructed to call sum(), product(), and average() using references, return two slices, and use lifetime annotations to help keep track of the variables.
指导学生使用引用调用 sum（）、product（） 和 average（），返回两个切片，并使用生命周期注释来帮助跟踪变量。

04:24:05 – 04:32:50
Lifetimes Solution 生命周期解决方案
Richard live codes the solution to the Lifetimes exercise.
理查德·利夫 （Richard live） 编写了 Lifetimes 练习的解决方案。

Wrapping Up 结束语

04:32:51 – 04:42:38
Wrapping Up 结束语
Richard wraps up the course by summarizing why someone would want to use Rust, providing additional resources for continued learning, and answering some student questions. Student questions regarding next project recommendations, where Rust is best applied, if Actix is a good framework for Rust, and what the job market for Rust looks like.
Richard 总结了为什么有人想要使用 Rust，为继续学习提供了额外的资源，并回答了一些学生的问题。学生关于下一个项目建议的问题，Rust 的最佳应用，Actix 是否是 Rust 的良好框架，以及 Rust 的就业市场是什么样子。