更新

2021年2月1日: Youtube视频

2021年1月4日: 支持在线查看 点击阅读

介绍

Rust是一种新的语言，已经有了很好的教科书。但是有时候它的教材很难，因为它的教材是给以英语为母语的人看的。现在很多公司和人学习Rust，如果有一本英语简单的书，他们可以学得更快。这本教材就是给这些公司和人用简单的英语来学习Rust的。

Rust是一门很新的语言，但已经非常流行。它之所以受欢迎，是因为它给你提供了C或C++的速度和控制力，但也给你提供了Python等其他较新语言的内存安全。它用一些新的想法来实现这一点，这些想法有时与其他语言不同。这意味着有一些新的东西需要学习，你不能只是 “边走边想”。Rust是一门语言，你必须思考一段时间才能理解。但如果你懂其他语言的话，它看起来还是很熟悉的，它是为了帮助你写好代码而生的。

我是谁？

我是一个生活在韩国的加拿大人，我在写Easy Rust的同时，也在思考如何让这里的公司开始使用它。我希望其他不以英语为第一语言的国家也能使用它。

简单英语学Rust

简单英语学Rust写于2020年7月至8月，长达400多页。如果你有任何问题，可以在这里或在LinkedIn上或在Twitter上联系我。如果你发现有什么不对的地方，或者要提出pull request，请继续。已经有超过20人帮助我们修复了代码中的错别字和问题，所以你也可以。我不是世界上最好的Rust专家，所以我总是喜欢听到新的想法，或者看看哪里可以让这本书变得更好。

• 第1部分 - 浏览器中的Rust
  • Rust Playground
  • 🚧 and ⚠️
  • 注释
  • 类型
    • 原始类型
  • 类型推导
    • 浮点数
  • 打印hello, world!
    • 声明变量和代码块
  • 显示和调试
    • 最小和最大的数
  • 可变性
    • 遮蔽
  • 栈，堆和指针
  • 关于打印的更多信息
  • 字符串
  • const和static
  • 关于引用的更多信息
  • 可变引用
    • 再谈shadowing
  • 函数的引用
  • 拷贝类型
    • 无值变量
  • 集合类型
    • 数组
  • 向量
  • 元组
  • 控制流
  • 结构体
  • 枚举
    • 使用多种类型的枚举
  • 循环
  • 实现结构和枚举
  • 解构
  • 引用和点运算符
  • 泛型
  • 选项和结果
    • 选项
    • 结果
  • 其他集合类型
    • HashMap和BTreeMap
    • HashSet和BTreeSet
    • 二叉堆
    • VecDeque
  • ?操作符
    • When panic and unwrap are good
  • trait
    • From trait
    • 在函数中使用字符串和&str
  • 链式方法
  • 迭代器
    • 迭代器如何工作
  • 闭包
    • 闭包中的_
    • 闭包和迭代器的有用方法
  • dbg! 宏和.检查器
  • &str的类型
  • 生命期
  • 内部可变性
    • Cell
    • RefCell
    • Mutex
    • RwLock
  • Cow
  • 类型别名
    • 在函数中导入和重命名
  • todo!宏
  • Rc
  • 多线程
  • 函数中的闭包
  • impl Trait
  • Arc
  • Channels
  • 阅读Rust文档
    • assert_eq!
    • 搜索
    • [src]按钮
    • trait信息
  • 属性
  • Box
  • Box around traits
  • 默认值和建造者模式
  • Deref和DerefMut
  • Crate和模块
  • 测试
    • 测试驱动的开发
  • 外部crate
    • rand
    • rayon
    • serde
    • regex
    • chrono
  • 标准库之旅
    • 数组
    • char
    • Integer
    • Floats
    • Bool
    • Vec
    • String
    • OsString和CString
    • Mem
    • Prelude
    • Time
    • 其他宏
    • 编写宏
• 第2部分 - 电脑上的Rust
  • cargo
  • 接受用户输入
  • 使用文件
  • cargo文档
  • 结束了吗？

第1部分 - 浏览器中的Rust

本书有两个部分。第1部分，你将在浏览器中就能学到尽可能多的Rust知识。实际上你几乎可以在不安装Rust的情况下学到所有你需要知道的东西，所以第1部分非常长。最后是第二部分。它要短得多，是关于电脑上的Rust。在这里，你将学习到其他一切你需要知道的、只能在浏览器之外进行的事情。例如:处理文件、接受用户输入、图形和个人设置。希望在第一部分结束时，你会喜欢Rust，以至于你会安装它。如果你不喜欢，也没问题—第一部分教了你很多，你不会介意的。

Rust Playground

也许你还不想安装Rust，这也没关系。你可以去https://play.rust-lang.org/，在不离开浏览器的情况下开始写Rust。你可以在那里写下你的代码，然后点击Run来查看结果。你可以在浏览器的Playground里面运行本书中的大部分示例。只有在接近结尾的时候，你才会看到无法在Playground运行的示例(比如打开文件)。

以下是使用Rust Playground时的一些提示。

• 用”Run”来运行你的代码

• 如果你想让你的代码更快，就把Debug改为Release。Debug:编译速度更快，运行速度更慢，包含调试信息。Release:编译速度更慢，运行速度更快，删除调试信息。

• 点击Share，得到一个网址链接，你可以用它来分享你的代码。如果你需要帮助，可以用它来分享你的代码。点击分享后，你可以点击Open a new thread in the Rust user forum，马上向那里的人寻求帮助。
• Rustfmt工具: Rustfmt会很好地格式化你的代码。
• TOOLS: Rustfmt会很好地格式化你的代码。Clippy会给你额外的信息，告诉你如何让你的代码更好。
• CONFIG: 在这里你可以把你的主题改成黑暗模式，这样你就可以在晚上工作了，还有很多其他配置。

如果你想安装Rust，请到这里https://www.rust-lang.org/tools/install，然后按照说明操作。通常你会使用rustup来安装和更新Rust。

🚧和⚠️

有时书中的代码例子不能用。如果一个例子不工作，它将会有一个🚧或⚠️在里面。🚧就像 “正在建设中”一样:它意味着代码不完整。Rust需要一个fn main()(一个主函数)来运行，但有时我们只是想看一些小的代码，所以它不会有fn main()。这些例子是正确的，但需要一个fn main()让你运行。而有些代码示例向你展示了一个问题，我们将解决这个问题。那些可能有一个fn main()，但会产生一个错误，所以它们会有一个⚠️。

注释

注释是给程序员看的，而不是给电脑看的。写注释是为了帮助别人理解你的代码。 这也有利于帮助你以后理解你的代码。 (很多人写了很好的代码，但后来却忘记了他们为什么要写它。)在Rust中写注释，你通常使用 //．

fn main() {
    // Rust programs start with fn main()
    // You put the code inside a block. It starts with { and ends with }
    let some_number = 100; // We can write as much as we want here and the compiler won't look at it
}

当你这样做时，编译器不会看//右边的任何东西。

还有一种注释，你用/*开始写，*/结束写。这个写在你的代码中间很有用。

fn main() {
    let some_number/*: i16*/ = 100;
}

对编译器来说，let some_number/*: i16*/ = 100;看起来像let some_number = 100;。

/* */形式对于超过一行的非常长的注释也很有用。在这个例子中，你可以看到你需要为每一行写//。但是如果您输入 /*，它不会停止，直到您用 */ 完成它。

fn main() {
    let some_number = 100; /* Let me tell you
    a little about this number.
    It's 100, which is my favourite number.
    It's called some_number but actually I think that... */
    let some_number = 100; // Let me tell you
    // a little about this number.
    // It's 100, which is my favourite number.
    // It's called some_number but actually I think that...
}

类型

Rust有很多类型，让你可以处理数字、字符等。有些类型很简单，有些类型比较复杂，你甚至可以创建自己的类型。

原始类型

Rust有简单的类型，这些类型被称为原始类型(原始=非常基本)。我们将从整数和char(字符)开始。整数是没有小数点的整数。整数有两种类型。

• 有符号的整数
• 无符号整数

符号是指+(加号)和-(减号)，所以有符号的整数可以是正数，也可以是负数(如+8，-8)。但无符号整数只能是正数，因为它们没有符号。

有符号的整数是 i8, i16, i32, i64, i128, 和 isize。

无符号的整数是 u8, u16, u32, u64, u128, 和 usize。

i或u后面的数字表示该数字的位数，所以位数多的数字可以大一些。8位=一个字节，所以i8是一个字节，i64是8个字节，以此类推。尺寸较大的数字类型可以容纳更大的数字。例如，u8最多可以容纳255，但u16最多可以容纳65535。而u128最多可以容纳340282366920938463463374607431768211455。

那么什么是isize和usize呢？这表示你电脑的位数。(你的电脑上的位数叫做你电脑的架构)。所以32位计算机上的isize和usize就像i32和u32，64位计算机上的isize和usize就像i64和u64。

整数类型不同的原因有很多。其中一个原因是计算机性能:较小的字节数处理速度更快。例如，数字-10作为i8是11110110，但作为i128是11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110110。但这里还有一些其他用法。

Rust中的字符叫做char. 每一个char都有一个数字:字母A是数字65，而字符友(中文的 “朋友”)是数字21451。这个数字列表被称为 “Unicode”。Unicode对使用较多的字符使用较小的数字，如A到Z，或0到9的数字，或空格。

fn main() {
    let first_letter = 'A';
    let space = ' '; // A space inside ' ' is also a char
    let other_language_char = 'Ꮔ'; // Thanks to Unicode, other languages like Cherokee display just fine too
    let cat_face = '😺'; // Emojis are chars too
}

使用最多的字符的数字小于256，它们可以装进u8。记住，u8是0加上255以内的所有数字，总共256个。这意味着 Rust 可以使用 as 将 u8 安全地 cast成 char。(“把 u8 cast成 char“意味着 “把 u8 假装成 char“)

用 as cast是有用的，因为 Rust 是非常严格的。它总是需要知道类型。 而不会让你同时使用两种不同的类型，即使它们都是整数。例如，这将无法工作:

fn main() { // main() is where Rust programs start to run. Code goes inside {} (curly brackets)
    let my_number = 100; // We didn't write a type of integer,
                         // so Rust chooses i32. Rust always
                         // chooses i32 for integers if you don't
                         // tell it to use a different type
    println!("{}", my_number as char); // ⚠️
}

原因是这样的:

error[E0604]: only `u8` can be cast as `char`, not `i32`
 --> src\main.rs:3:20
  |
3 |     println!("{}", my_number as char);
  |                    ^^^^^^^^^^^^^^^^^

幸运的是，我们可以用as轻松解决这个问题。我们不能把i32转成char，但我们可以把i32转成u8，然后把u8转换成char。所以在一行中，我们使用 as 将 my_number 变为 u8，再将其变为 char。现在可以编译了。

fn main() {
    let my_number = 100;
    println!("{}", my_number as u8 as char);
}

它打印的是d，因为那是100对应的char。

然而，更简单的方法是告诉 Rust my_number 是 u8。下面是你的做法。

fn main() {
    let my_number: u8 = 100; //  change my_number to my_number: u8
    println!("{}", my_number as char);
}

所以这就是Rust中所有不同数字类型的两个原因。这里还有一个原因:usize是Rust用于索引的大小。(索引的意思是 “哪项是第一”，”哪项是第二”等等)usize是索引的最佳大小，因为:

• 索引不能是负数，所以它需要是一个带u的数字
• 它应该是大的，因为有时你需要索引很多东西，但。
• 不可能是u64，因为32位电脑不能使用u64。

所以Rust使用了usize，这样你的计算机就可以得到它能读到的最大的数字进行索引。

我们再来了解一下char。你看到char总是一个字符，并且使用''而不是""。

所有的 字符 都使用4个字节的内存，因为4个字节足以容纳任何种类的字符:

• 基本字母和符号通常需要4个字节中的1个：a b 1 2 + - = $ @
• 其他字母，如德语的 Umlauts 或重音，需要4个字节中的2个： ä ö ü ß è é à ñ
• 韩文、日文或中文字符需要3或4个字节： 国 안 녕

当使用字符作为字符串的一部分时，字符串被编码以使用每个字符所需的最小内存量。

我们可以用.len()来看一下。

fn main() {
    println!("Size of a char: {}", std::mem::size_of::<char>()); // 4 bytes
    println!("Size of string containing 'a': {}", "a".len()); // .len() gives the size of the string in bytes
    println!("Size of string containing 'ß': {}", "ß".len());
    println!("Size of string containing '国': {}", "国".len());
    println!("Size of string containing '𓅱': {}", "𓅱".len());
}

这样打印出来。

Size of a char: 4
Size of string containing 'a': 1
Size of string containing 'ß': 2
Size of string containing '国': 3
Size of string containing '𓅱': 4

可以看到，a是一个字节，德文的ß是两个字节，日文的国是三个字节，古埃及的𓅱是4个字节。

fn main() {
    let slice = "Hello!";
    println!("Slice is {} bytes.", slice.len());
    let slice2 = "안녕!"; // Korean for "hi"
    println!("Slice2 is {} bytes.", slice2.len());
}

这个打印:

Slice is 6 bytes.
Slice2 is 7 bytes.

slice的长度是6个字符，6个字节，但slice2的长度是3个字符，7个字节。

如果.len()给出的是以字节为单位的大小，那么以字符为单位的大小呢？这些方法我们后面会学习，但你只要记住.chars().count()就可以了。.chars().count() 将你写的东西变成字符，然后计算有多少个字符。

fn main() {
    let slice = "Hello!";
    println!("Slice is {} bytes and also {} characters.", slice.len(), slice.chars().count());
    let slice2 = "안녕!";
    println!("Slice2 is {} bytes but only {} characters.", slice2.len(), slice2.chars().count());
}

这就打印出来了。

Slice is 6 bytes and also 6 characters.
Slice2 is 7 bytes but only 3 characters.

类型推导

类型推导的意思是，如果你不告诉编译器类型，但它可以自己决定，它就会决定。编译器总是需要知道变量的类型，但你并不总是需要告诉它。实际上，通常你不需要告诉它。例如，对于let my_number = 8，my_number将是一个i32。这是因为如果你不告诉它，编译器会选择i32作为整数。但是如果你说let my_number: u8 = 8，它就会把my_number变成u8，因为你告诉它u8。

通常编译器都能猜到。但有时你需要告诉它，原因有两个。

1) 你正在做一些非常复杂的事情，而编译器不知道你想要的类型。 2) 你想要一个不同的类型(例如，你想要一个i128，而不是i32)。

要指定一个类型，请在变量名后添加一个冒号。

fn main() {
    let small_number: u8 = 10;
}

对于数字，你可以在数字后面加上类型。你不需要空格—只需要在数字后面直接输入。

fn main() {
    let small_number = 10u8; // 10u8 = 10 of type u8
}

如果你想让数字便于阅读，也可以加上_。

fn main() {
    let small_number = 10_u8; // This is easier to read
    let big_number = 100_000_000_i32; // 100 million is easy to read with _
}

_不会改变数字。它只是为了让你方便阅读。而且你用多少个_都没有关系。

fn main() {
    let number = 0________u8;
    let number2 = 1___6______2____4______i32;
    println!("{}, {}", number, number2);
}

这样打印出的是0, 1624。

浮点数

浮点数是带有小数点的数字。5.5是一个浮点数，6是一个整数。5.0也是一个浮点数，甚至5.也是一个浮点数。

fn main() {
    let my_float = 5.; // Rust sees . and knows that it is a float
}

但类型不叫float，叫f32和f64。这和整数一样:f后面的数字显示的是位数。如果你不写类型，Rust会选择f64。

当然，只有同一类型的浮点数可以一起使用。所以你不能把f32加到f64上。

fn main() {
    let my_float: f64 = 5.0; // This is an f64
    let my_other_float: f32 = 8.5; // This is an f32
    let third_float = my_float + my_other_float; // ⚠️
}

当你尝试运行这个时，Rust会说。

error[E0308]: mismatched types
 --> src\main.rs:5:34
  |
5 |     let third_float = my_float + my_other_float;
  |                                  ^^^^^^^^^^^^^^ expected `f64`, found `f32`

当你使用错误的类型时，编译器会写 “expected (type), found (type)”。它这样读取你的代码。

fn main() {
    let my_float: f64 = 5.0; // The compiler sees an f64
    let my_other_float: f32 = 8.5; // The compiler sees an f32. It is a different type.
    let third_float = my_float + // You want to add my_float to something, so it must be an f64 plus another f64. Now it expects an f64...
    let third_float = my_float + my_other_float;  // ⚠️ but it found an f32. It can't add them.
}

所以，当你看到 “expected(type)，found(type)”时，你必须找到为什么编译器预期的是不同的类型。

当然，用简单的数字很容易解决。你可以用as把f32转成f64。

fn main() {
    let my_float: f64 = 5.0;
    let my_other_float: f32 = 8.5;
    let third_float = my_float + my_other_float as f64; // my_other_float as f64 = use my_other_float like an f64
}

或者更简单，去掉类型声明。(“声明一个类型”=”告诉Rust使用该类型”)Rust会选择可以加在一起的类型。

fn main() {
    let my_float = 5.0; // Rust will choose f64
    let my_other_float = 8.5; // Here again it will choose f64
    let third_float = my_float + my_other_float;
}

Rust编译器很聪明，如果你需要f32，就不会选择f64。

fn main() {
    let my_float: f32 = 5.0;
    let my_other_float = 8.5; // Usually Rust would choose f64,
    let third_float = my_float + my_other_float; // but now it knows that you need to add it to an f32. So it chooses f32 for my_other_float too
}

打印hello, world!

当你启动一个新的Rust程序时，它总是有这样的代码。

fn main() {
    println!("Hello, world!");
}

• fn的意思是函数。

• main是启动程序的函数。

• ()表示我们没有给函数任何变量来启动。

{}被称为代码块。这是代码所在的空间。

println!是一个宏，打印到控制台。一个宏就像一个函数，为你写代码。宏后面有一个!。我们以后会学习如何创建宏。现在，请记住，!表示它是一个宏。

为了学习;，我们将创建另一个函数。首先，在main中，我们将打印一个数字8。

fn main() {
    println!("Hello, world number {}!", 8);
}

println!中的{}的意思是 “把变量放在这里面”。这样就会打印出Hello, world number 8!。

我们可以像之前一样，放更多的东西进去。

fn main() {
    println!("Hello, worlds number {} and {}!", 8, 9);
}

这将打印出 Hello, worlds number 8 and 9!。

现在我们来创建函数。

fn number() -> i32 {
    8
}
fn main() {
    println!("Hello, world number {}!", number());
}

这也会打印出 Hello, world number 8!。当Rust查看number()时，它看到一个函数。这个函数:

• 没有参数(因为它有())
• 返回一个i32。->(称为 “瘦箭”)显示了函数返回的内容

函数内部只有8。因为没有;，所以这就是它返回的值。如果它有一个;，它将不会返回任何东西(它会返回一个())。如果它有 ;，Rust 不会编译通过，因为需要返回的是 i32，而 ; 返回 ()，不是 i32。

fn main() {
    println!("Hello, world number {}", number());
}
fn number() -> i32 {
    8;  // ⚠️
}

5 | fn number() -> i32 {
  |    ------      ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
6 |     8;
  |      - help: consider removing this semicolon

这意味着 “你告诉我number()返回的是i32，但你加了一个;，所以它什么都不返回”。所以编译器建议去掉分号。

你也可以写return 8;，但在Rust中，正常情况下只需将;改为return即可。

当你想给一个函数赋予变量时，把它们放在()里面。你必须给它们起个名字，写上类型。

fn multiply(number_one: i32, number_two: i32) { // Two i32s will enter the function. We will call them number_one and number_two.
    let result = number_one * number_two;
    println!("{} times {} is {}", number_one, number_two, result);
}
fn main() {
    multiply(8, 9); // We can give the numbers directly
    let some_number = 10; // Or we can declare two variables
    let some_other_number = 2;
    multiply(some_number, some_other_number); // and put them in the function
}

我们也可以返回一个i32。只要把最后的分号去掉就可以了:

fn multiply(number_one: i32, number_two: i32) -> i32 {
    let result = number_one * number_two;
    println!("{} times {} is {}", number_one, number_two, result);
    result // this is the i32 that we return
}
fn main() {
    let multiply_result = multiply(8, 9); // We used multiply() to print and to give the result to multiply_result
}

声明变量和代码块

使用let声明一个变量(声明一个变量=告诉Rust创建一个变量)。

fn main() {
    let my_number = 8;
    println!("Hello, number {}", my_number);
}

变量在代码块{}内开始和结束。在这个例子中，my_number在我们调用println!之前结束，因为它在自己的代码块里面。

fn main() {
    {
        let my_number = 8; // my_number starts here
                           // my_number ends here!
    }
    println!("Hello, number {}", my_number); // ⚠️ there is no my_number and
                                             // println!() can't find it
}

你可以使用代码块来返回一个值。

fn main() {
    let my_number = {
    let second_number = 8;
        second_number + 9 // No semicolon, so the code block returns 8 + 9.
                          // It works just like a function
    };
    println!("My number is: {}", my_number);
}

如果在代码块内部添加分号，它将返回 () (无)。

fn main() {
    let my_number = {
    let second_number = 8; // declare second_number,
        second_number + 9; // add 9 to second_number
                           // but we didn't return it!
                           // second_number dies now
    };
    println!("My number is: {:?}", my_number); // my_number is ()
}

那么为什么我们要写{:?}而不是{}呢？我们现在就来谈谈这个问题。

显示和调试

Rust中简单的变量可以用{}里面的println!打印。但是有些变量不能，你需要debug print。Debug打印是给程序员打印的，因为它通常会显示更多的信息。Debug有时看起来并不漂亮，因为它有额外的信息来帮助你。

你怎么知道你是否需要{:?}而不是{}？编译器会告诉你。比如说

fn main() {
    let doesnt_print = ();
    println!("This will not print: {}", doesnt_print); // ⚠️
}

当我们运行这个时，编译器会说:

error[E0277]: `()` doesn't implement `std::fmt::Display`
 --> src\main.rs:3:41
  |
3 |     println!("This will not print: {}", doesnt_print);
  |                                         ^^^^^^^^^^^^ `()` cannot be formatted with the default formatter
  |
  = help: the trait `std::fmt::Display` is not implemented for `()`
  = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead
  = note: required by `std::fmt::Display::fmt`
  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

信息比较多，但重要的部分是 you may be able to use {:?} (or {:#?} for pretty-print) instead. 这意味着你可以试试{:?}，也可以试试{:#?} {:#?}叫做 “漂亮打印”。它和{:?}一样，但是在更多的行上打印出不同的格式。

所以Display就是用{}打印，Debug就是用{:?}打印。

还有一点:如果你不想要新的一行，你也可以使用print!而不用ln。

fn main() {
    print!("This will not print a new line");
    println!(" so this will be on the same line");
}

这将打印This will not print a new line so this will be on the same line。

最小和最大的数

如果你想看最小和最大的数字，你可以用MIN和MAX。std的意思是 “标准库”，拥有Rust的所有主要函数等。我们将在以后学习标准库。但与此同时，你可以记住，这就是你如何获得一个类型的最小和最大的数字。

fn main() {
    println!("The smallest i8 is {} and the biggest i8 is {}.", std::i8::MIN, std::i8::MAX); // hint: printing std::i8::MIN means "print MIN inside of the i8 section in the standard library"
    println!("The smallest u8 is {} and the biggest u8 is {}.", std::u8::MIN, std::u8::MAX);
    println!("The smallest i16 is {} and the biggest i16 is {}.", std::i16::MIN, std::i16::MAX);
    println!("The smallest u16 is {} and the biggest u16 is {}.", std::u16::MIN, std::u16::MAX);
    println!("The smallest i32 is {} and the biggest i32 is {}.", std::i32::MIN, std::i32::MAX);
    println!("The smallest u32 is {} and the biggest u32 is {}.", std::u32::MIN, std::u32::MAX);
    println!("The smallest i64 is {} and the biggest i64 is {}.", std::i64::MIN, std::i64::MAX);
    println!("The smallest u64 is {} and the biggest u64 is {}.", std::u64::MIN, std::u64::MAX);
    println!("The smallest i128 is {} and the biggest i128 is {}.", std::i128::MIN, std::i128::MAX);
    println!("The smallest u128 is {} and the biggest u128 is {}.", std::u128::MIN, std::u128::MAX);
}

将会打印:

The smallest i8 is -128 and the biggest i8 is 127.
The smallest u8 is 0 and the biggest u8 is 255.
The smallest i16 is -32768 and the biggest i16 is 32767.
The smallest u16 is 0 and the biggest u16 is 65535.
The smallest i32 is -2147483648 and the biggest i32 is 2147483647.
The smallest u32 is 0 and the biggest u32 is 4294967295.
The smallest i64 is -9223372036854775808 and the biggest i64 is 9223372036854775807.
The smallest u64 is 0 and the biggest u64 is 18446744073709551615.
The smallest i128 is -170141183460469231731687303715884105728 and the biggest i128 is 170141183460469231731687303715884105727.
The smallest u128 is 0 and the biggest u128 is 340282366920938463463374607431768211455.

可变性

当你用let声明一个变量时，它是不可改变的(不能改变)。

这将无法工作:

fn main() {
    let my_number = 8;
    my_number = 10; // ⚠️
}

编译器说:error[E0384]: cannot assign twice to immutable variable my_number。这是因为如果你只写let，变量是不可变的。

但有时你想改变你的变量。要创建一个可以改变的变量，就在let后面加上mut。

fn main() {
    let mut my_number = 8;
    my_number = 10;
}

现在没有问题了。

但是，你不能改变类型:甚至mut也不能让你这样做:这将无法工作。

fn main() {
    let mut my_variable = 8; // it is now an i32. That can't be changed
    my_variable = "Hello, world!"; // ⚠️
}

你会看到编译器发出的同样的 “预期”信息。expected integer, found &str. &str是一个字符串类型，我们很快就会知道。

遮蔽

shadowing是指使用let声明一个与另一个变量同名的新变量。它看起来像可变性，但完全不同。shadowing看起来是这样的:

fn main() {
    let my_number = 8; // This is an i32
    println!("{}", my_number); // prints 8
    let my_number = 9.2; // This is an f64 with the same name. But it's not the first my_number - it is completely different!
    println!("{}", my_number) // Prints 9.2
}

这里我们说我们用一个新的 “let绑定”对my_number进行了 “shadowing”。

那么第一个my_number是否被销毁了呢？没有，但是当我们调用my_number时，我们现在得到my_number的f64。因为它们在同一个作用域块中(同一个 {})，我们不能再看到第一个 my_number。

但如果它们在不同的块中，我们可以同时看到两个。 例如:

fn main() {
    let my_number = 8; // This is an i32
    println!("{}", my_number); // prints 8
    {
        let my_number = 9.2; // This is an f64. It is not my_number - it is completely different!
        println!("{}", my_number) // Prints 9.2
                                  // But the shadowed my_number only lives until here.
                                  // The first my_number is still alive!
    }
    println!("{}", my_number); // prints 8
}

因此，当你对一个变量进行shadowing处理时，你不会破坏它。你屏蔽了它。

那么shadowing的好处是什么呢？当你需要经常改变一个变量的时候，shadowing是很好的。想象一下，你想用一个变量做很多简单的数学运算。

fn times_two(number: i32) -> i32 {
    number * 2
}
fn main() {
    let final_number = {
        let y = 10;
        let x = 9; // x starts at 9
        let x = times_two(x); // shadow with new x: 18
        let x = x + y; // shadow with new x: 28
        x // return x: final_number is now the value of x
    };
    println!("The number is now: {}", final_number)
}

如果没有shadowing，你将不得不考虑不同的名称，尽管你并不关心x。

fn times_two(number: i32) -> i32 {
    number * 2
}
fn main() {
    // Pretending we are using Rust without shadowing
    let final_number = {
        let y = 10;
        let x = 9; // x starts at 9
        let x_twice = times_two(x); // second name for x
        let x_twice_and_y = x_twice + y; // third name for x!
        x_twice_and_y // too bad we didn't have shadowing - we could have just used x
    };
    println!("The number is now: {}", final_number)
}

一般来说，你在Rust中看到的shadowing就是这种情况。它发生在你想快速取用变量，对它做一些事情，然后再做其他事情的地方。而你通常将它用于那些你不太关心的快速变量。

栈、堆和指针

栈、堆和指针在Rust中非常重要。

栈和堆是计算机中保存内存的两个地方。重要的区别是:

栈的速度非常快, 但堆的速度就不那么快了. 它也不是超慢，但栈总是更快。但是你不能一直使用栈，因为:

• Rust需要在编译时知道一个变量的大小。所以像i32这样的简单变量就放在堆栈上，因为我们知道它们的确切大小。你总是知道i32要4字节，因为32位=4字节。所以i32总是可以放在栈上。
• 但有些类型在编译时不知道大小。但是栈需要知道确切的大小。那么你该怎么做呢？首先你把数据放在堆中，因为堆中可以有任何大小的数据。然后为了找到它，一个指针就会进入栈。这很好，因为我们总是知道指针的大小。所以，计算机就会先去栈，读取指针，然后跟着指针到数据所在的堆。

指针听起来很复杂，但它们很容易。指针就像一本书的目录。想象一下这本书。

MY BOOK
TABLE OF CONTENTS
Chapter                        Page
Chapter 1: My life              1
Chapter 2: My cat               15
Chapter 3: My job               23
Chapter 4: My family            30
Chapter 5: Future plans         43

所以这就像五个指针。你可以阅读它们，找到它们所说的信息。”我的生活”这一章在哪里？在第1页(它指向第1页)。”我的工作”这一章在哪里？它在第23页。

在Rust中通常看到的指针叫做引用。这是重要的部分，要知道:一个引用指向另一个值的内存。引用意味着你借了这个值，但你并不拥有它。这和我们的书一样:目录并不拥有信息。章节才是信息的主人。在Rust中，引用文献的前面有一个&。所以:

• let my_variable = 8是一个普通的变量，但是:
• let my_reference = &my_variable是一个引用。

你把 my_reference = &my_variable 读成这样: “my_reference是对my_variable的引用”. 或者:”my_reference是对my_variable的引用”。

这意味着my_reference只看my_variable的数据。my_variable仍然拥有它的数据。

你也可以有一个引用的引用，或者任何数量的引用。

fn main() {
    let my_number = 15; // This is an i32
    let single_reference = &my_number; //  This is a &i32
    let double_reference = &single_reference; // This is a &&i32
    let five_references = &&&&&my_number; // This is a &&&&&i32
}

这些都是不同的类型，就像 “朋友的朋友”和 “朋友”不同一样。

关于打印的更多信息

在Rust中，你几乎可以用任何你想要的方式打印东西。这里有一些关于打印的事情需要知道。

添加 \n 将会产生一个新行，而 \t 将会产生一个标签。

fn main() {
    // Note: this is print!, not println!
    print!("\t Start with a tab\nand move to a new line");
}

这样就可以打印了。

         Start with a tab
and move to a new line

""里面可以写过很多行都没有问题，但是要注意间距。

fn main() {
    // Note: After the first line you have to start on the far left.
    // If you write directly under println!, it will add the spaces
    println!("Inside quotes
you can write over
many lines
and it will print just fine.");
    println!("If you forget to write
    on the left side, the spaces
    will be added when you print.");
}

这个打印出来的。

Inside quotes
you can write over
many lines
and it will print just fine.
If you forget to write
    on the left side, the spaces
    will be added when you print.

如果你想打印\n这样的字符(称为 “转义字符”)，你可以多加一个\。

fn main() {
    println!("Here are two escape characters: \\n and \\t");
}

这样就可以打印了。

Here are two escape characters: \n and \t

有时你有太多的 " 和转义字符，并希望 Rust 忽略所有的字符。要做到这一点，您可以在开头添加 r#，在结尾添加 #。

fn main() {
    println!("He said, \"You can find the file at c:\\files\\my_documents\\file.txt.\" Then I found the file."); // We used \ five times here
    println!(r#"He said, "You can find the file at c:\files\my_documents\file.txt." Then I found the file."#)
}

这打印的是同样的东西，但使用 r# 使人类更容易阅读。

He said, "You can find the file at c:\files\my_documents\file.txt." Then I found the file.
He said, "You can find the file at c:\files\my_documents\file.txt." Then I found the file.

如果你需要在里面打印#，那么你可以用r##开头，用##结尾。如果你需要打印多个连续的#，可以在每边多加一个#。

下面是四个例子。

fn main() {
    let my_string = "'Ice to see you,' he said."; // single quotes
    let quote_string = r#""Ice to see you," he said."#; // double quotes
    let hashtag_string = r##"The hashtag #IceToSeeYou had become very popular."##; // Has one # so we need at least ##
    let many_hashtags = r####""You don't have to type ### to use a hashtag. You can just use #.""####; // Has three ### so we need at least ####
    println!("{}\n{}\n{}\n{}\n", my_string, quote_string, hashtag_string, many_hashtags);
}

这将打印:

'Ice to see you,' he said.
"Ice to see you," he said.
The hashtag #IceToSeeYou had become very popular.
"You don't have to type ### to use a hashtag. You can just use #."

r#还有另一个用途:使用它，你可以使用关键字(如let、fn等)作为变量名。

fn main() {
    let r#let = 6; // The variable's name is let
    let mut r#mut = 10; // This variable's name is mut
}

r#之所以有这个功能，是因为旧版本的Rust的关键字比现在的Rust少。所以有了r#就可以避免以前不是关键字的变量名的错误。

又或者因为某些原因，你确实需要一个函数的名字，比如return。那么你可以这样写:

fn r#return() -> u8 {
    println!("Here is your number.");
    8
}
fn main() {
    let my_number = r#return();
    println!("{}", my_number);
}

这样打印出来的结果是:

Here is your number.
8

所以你可能不需要它，但是如果你真的需要为一个变量使用一个关键字，那么你可以使用r#。

如果你想打印&str或char的字节，你可以在字符串前写上b就可以了。这适用于所有ASCII字符。这些是所有的ASCII字符。

☺☻♥♦♣♠♫☼►◄↕‼¶§▬↨↑↓→∟↔▲▼123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

所以，当你打印这个

fn main() {
    println!("{:?}", b"This will look like numbers");
}

这就是结果:

[84, 104, 105, 115, 32, 119, 105, 108, 108, 32, 108, 111, 111, 107, 32, 108, 105, 107, 101, 32, 110, 117, 109, 98, 101, 114, 115]

对于char来说，这叫做一个字节，对于&str来说，这叫做一个字节字符串。

如果你需要的话，也可以把b和r放在一起。

fn main() {
    println!("{:?}", br##"I like to write "#"."##);
}

这将打印出 [73, 32, 108, 105, 107, 101, 32, 116, 111, 32, 119, 114, 105, 116, 101, 32, 34, 35, 34, 46]。

还有一个Unicode转义，可以让你在字符串中打印任何Unicode字符: \u{}。{}里面有一个十六进制数字可以打印。下面是一个简短的例子，说明如何获得Unicode数字，以及如何再次打印它。

fn main() {
    println!("{:X}", '행' as u32); // Cast char as u32 to get the hexadecimal value
    println!("{:X}", 'H' as u32);
    println!("{:X}", '居' as u32);
    println!("{:X}", 'い' as u32);
    println!("\u{D589}, \u{48}, \u{5C45}, \u{3044}"); // Try printing them with unicode escape \u
}

我们知道，println!可以和{}(用于显示)或{:?}(用于调试)一起打印，再加上{:#?}就可以进行漂亮的打印。但是还有很多其他的打印方式。

例如，如果你有一个引用，你可以用{:p}来打印指针地址。指针地址指的是电脑内存中的位置。

fn main() {
    let number = 9;
    let number_ref = &number;
    println!("{:p}", number_ref);
}

这可以打印0xe2bc0ffcfc或其他地址。每次可能都不一样，这取决于你的计算机存储的位置。

或者你可以打印二进制、十六进制和八进制。

fn main() {
    let number = 555;
    println!("Binary: {:b}, hexadecimal: {:x}, octal: {:o}", number, number, number);
}

这将打印出Binary: 1000101011, hexadecimal: 22b, octal: 1053。

或者你可以添加数字来改变顺序。第一个变量将在索引0中，下一个在索引1中，以此类推。

fn main() {
    let father_name = "Vlad";
    let son_name = "Adrian Fahrenheit";
    let family_name = "Țepeș";
    println!("This is {1} {2}, son of {0} {2}.", father_name, son_name, family_name);
}

father_name在0位，son_name在1位，family_name在2位。所以它打印的是This is Adrian Fahrenheit Țepeș, son of Vlad Țepeș。

也许你有一个非常复杂的字符串要打印，{}大括号内有太多的变量。或者你需要不止一次的打印一个变量。那么在{}中添加名称就会有帮助。

fn main() {
    println!(
        "{city1} is in {country} and {city2} is also in {country},
but {city3} is not in {country}.",
        city1 = "Seoul",
        city2 = "Busan",
        city3 = "Tokyo",
        country = "Korea"
    );
}

这样就可以打印了。

Seoul is in Korea and Busan is also in Korea,
but Tokyo is not in Korea.

如果你愿意，也可以在Rust中进行非常复杂的打印。下面展示怎样做：

{variable:padding alignment minimum.maximum}

要理解这一点，请看

1) 你想要一个变量名吗？先写出来，就像我们上面写{country}一样。 (如果你想做更多的事情，就在后面加一个:) 2) 你想要一个填充字符吗？例如，55加上三个 “填充零”就像00055。 3) padding的对齐方式(左/中/右)？ 4) 你想要一个最小长度吗？(写一个数字就可以了) 5) 你想要一个最大长度吗？(写一个数字，前面有一个.)

例如，我想写 “a”，左边有五个ㅎ，右边有五个ㅎ。

fn main() {
    let letter = "a";
    println!("{:ㅎ^11}", letter);
}

这样打印出来的结果是ㅎㅎㅎㅎㅎaㅎㅎㅎㅎㅎ。我们看看1)到5)的这个情况，就能明白编译器是怎么解读的：

• 你要不要变量名？{:ㅎ^11}没有变量名。:之前没有任何内容。
• 你需要一个填充字符吗？{:ㅎ^11} 是的:ㅎ”在:后面，有一个^。<表示变量在填充字符左边，>表示在填充字符右边，^表示在填充字符中间。
• 要不要设置最小长度？{:ㅎ^11}是:后面有一个11。
• 你想要一个最大长度吗？{:ㅎ^11} 不是:前面没有.的数字。

下面是多种类型的格式化的例子:

fn main() {
    let title = "TODAY'S NEWS";
    println!("{:-^30}", title); // no variable name, pad with -, put in centre, 30 characters long
    let bar = "|";
    println!("{: <15}{: >15}", bar, bar); // no variable name, pad with space, 15 characters each, one to the left, one to the right
    let a = "SEOUL";
    let b = "TOKYO";
    println!("{city1:-<15}{city2:->15}", city1 = a, city2 = b); // variable names city1 and city2, pad with -, one to the left, one to the right
}

它打印出来了。

---------TODAY'S NEWS---------
|                            |
SEOUL--------------------TOKYO

字符串

Rust有两种主要类型的字符串。String和&str. 有什么区别呢？

• &str是一个简单的字符串。当你写let my_variable = "Hello, world!"时，你会创建一个&str。&str是非常快的。
• String是一个更复杂的字符串。它比较慢，但它有更多的功能。String是一个指针，数据在堆上。

另外注意，&str前面有&，因为你需要一个引用来使用str。这是因为我们上面看到的原因:堆需要知道大小。所以我们给它一个&，它知道大小，然后它就高兴了。另外，因为你用一个&与一个str交互，你并不拥有它。但是一个String是一个拥有的类型。我们很快就会知道为什么这一点很重要。

&str和String都是UTF-8。例如，你可以写

fn main() {
    let name = "서태지"; // This is a Korean name. No problem, because a &str is UTF-8.
    let other_name = String::from("Adrian Fahrenheit Țepeș"); // Ț and ș are no problem in UTF-8.
}

你可以在String::from("Adrian Fahrenheit Țepeș")中看到，很容易从&str中创建一个String。这两种类型虽然不同，但联系非常紧密。

你甚至可以写表情符号，这要感谢UTF-8。

fn main() {
    let name = "😂";
    println!("My name is actually {}", name);
}

在你的电脑上，会打印My name is actually 😂，除非你的命令行不能打印。那么它会显示My name is actually �。但Rust对emojis或其他Unicode没有问题。

我们再来看看str使用&的原因，以确保我们理解。

• str是一个动态大小的类型(动态大小=大小可以不同)。比如 “서태지”和 “Adrian Fahrenheit Țepeș”这两个名字的大小是不一样的。

fn main() {
    println!("A String is always {:?} bytes. It is Sized.", std::mem::size_of::<String>()); // std::mem::size_of::<Type>() gives you the size in bytes of a type
    println!("And an i8 is always {:?} bytes. It is Sized.", std::mem::size_of::<i8>());
    println!("And an f64 is always {:?} bytes. It is Sized.", std::mem::size_of::<f64>());
    println!("But a &str? It can be anything. '서태지' is {:?} bytes. It is not Sized.", std::mem::size_of_val("서태지")); // std::mem::size_of_val() gives you the size in bytes of a variable
    println!("And 'Adrian Fahrenheit Țepeș' is {:?} bytes. It is not Sized.", std::mem::size_of_val("Adrian Fahrenheit Țepeș"));
}

这个打印:

A String is always 24 bytes. It is Sized.
And an i8 is always 1 bytes. It is Sized.
And an f64 is always 8 bytes. It is Sized.
But a &str? It can be anything. '서태지' is 9 bytes. It is not Sized.
And 'Adrian Fahrenheit Țepeș' is 25 bytes. It is not Sized.

这就是为什么我们需要一个 &，因为 & 是一个指针，而 Rust 知道指针的大小。所以指针会放在栈中。如果我们写str，Rust就不知道该怎么做了，因为它不知道指针的大小。

有很多方法可以创建String。下面是一些。

• String::from("This is the string text"); 这是String的一个方法，它接受文本并创建一个String.
• "This is the string text".to_string(). 这是&str的一个方法，使其成为一个String。
• format! 宏。 这和println!一样，只是它创建了一个字符串，而不是打印。所以你可以这样做:

fn main() {
    let my_name = "Billybrobby";
    let my_country = "USA";
    let my_home = "Korea";
    let together = format!(
        "I am {} and I come from {} but I live in {}.",
        my_name, my_country, my_home
    );
}

现在我们有了一个一起命名的字符串，但还没有打印出来。

还有一种创建String的方法叫做.into()，但它有点不同，因为.into()并不只是用来创建String。有些类型可以很容易地使用From和.into()转换为另一种类型，并从另一种类型转换出来。而如果你有From，那么你也有.into()。From 更加清晰，因为你已经知道了类型:你知道 String::from("Some str") 是一个来自 &str 的 String。但是对于.into()，有时候编译器并不知道。

fn main() {
    let my_string = "Try to make this a String".into(); // ⚠️
}

Rust不知道你要的是什么类型，因为很多类型都可以从一个&str创建出来。它说:”我可以把一个&str做成很多东西。你想要哪一种？”

error[E0282]: type annotations needed
 --> src\main.rs:2:9
  |
2 |     let my_string = "Try to make this a String".into();
  |         ^^^^^^^^^ consider giving `my_string` a type

所以你可以这样做:

fn main() {
    let my_string: String = "Try to make this a String".into();
}

现在你得到了一个字符串。

const和static

有两种声明值的方法，不仅仅是用let。它们是const和static。另外，Rust不会使用类型推理：你需要为它们编写类型。这些都是用于不改变的值（const意味着常量）。区别在于:

• const是用于不改变的值，当使用它时，名字会被替换成值。
• static与const类似，但有一个固定的内存位置，可以作为一个全局变量使用。

所以它们几乎是一样的。Rust程序员几乎总是使用const。

一般用全大写字母作为名字，而且通常在main之外，这样它们就可以在整个程序中生存。

两个例子是 const NUMBER_OF_MONTHS: u32 = 12; 和 static SEASONS: [&str; 4] = ["Spring", "Summer", "Fall", "Winter"];

关于引用的更多信息

引用在Rust中非常重要。Rust使用引用来确保所有的内存访问是安全的。我们知道，我们使用&来创建一个引用。

fn main() {
    let country = String::from("Austria");
    let ref_one = &country;
    let ref_two = &country;
    println!("{}", ref_one);
}

这样就会打印出Austria。

在代码中，country是一个String。然后我们创建了两个country的引用。它们的类型是&String，你说这是一个 “字符串的引用”。我们可以创建三个引用或者一百个对 country 的引用，这都没有问题。

但这是一个问题。

fn return_str() -> &str {
    let country = String::from("Austria");
    let country_ref = &country;
    country_ref // ⚠️
}
fn main() {
    let country = return_str();
}

return_str()函数创建了一个String，然后它创建了一个对String的引用。然后它试图返回引用。但是country这个String只活在函数里面，然后它就死了。一旦一个变量消失了，计算机就会清理内存，并将其用于其他用途。所以在函数结束后，country_ref引用的是已经消失的内存，这是不对的。Rust防止我们在这里犯内存的错误。

这就是我们上面讲到的 “拥有”类型的重要部分。因为你拥有一个String，你可以把它传给别人。但是如果 &String 的 String 死了，那么 &String 就会死掉，所以你不能把它的 “所有权”传给别人。

可变引用

如果您想使用一个引用来改变数据，您可以使用一个可变引用。对于可变引用，您可以写 &mut 而不是 &。

fn main() {
    let mut my_number = 8; // don't forget to write mut here!
    let num_ref = &mut my_number;
}

那么这两种类型是什么呢？my_number是i32，num_ref是&mut i32(我们说是 “可变引用i32“)。

所以我们用它来给my_number加10。但是你不能写num_ref += 10，因为num_ref不是i32的值，它是一个&i32。其实这个值就在i32里面。为了达到值所在的地方，我们用*。*的意思是 “我不要引用，我要引用对应的值”。换句话说，一个*与&是相反的。另外，一个*抹去了一个&。

fn main() {
    let mut my_number = 8;
    let num_ref = &mut my_number;
    *num_ref += 10; // Use * to change the i32 value.
    println!("{}", my_number);
    let second_number = 800;
    let triple_reference = &&&second_number;
    println!("Second_number = triple_reference? {}", second_number == ***triple_reference);
}

这个打印:

18
Second_number = triple_reference? true

因为使用&叫做 “引用”，所以使用*叫做 “dereferencing”。

Rust有两个规则，分别是可变引用和不可变引用。它们非常重要，但也很容易记住，因为它们很有意义。

• 规则1。如果你只有不可变引用，你可以有任意多的引用。1个也行，3个也行，1000个也行，没问题。
• 规则2: 如果你有一个可变引用，你只能有一个。另外，你不能同时使用一个不可变引用和一个可变引用。

这是因为可变引用可以改变数据。如果你在其他引用读取数据时改变数据，你可能会遇到问题。

一个很好的理解方式是思考一个Powerpoint演示。

情况一是关于只有一个可变引用

情境一 一个员工正在编写一个Powerpoint演示文稿，他希望他的经理能帮助他。他希望他的经理能帮助他。该员工将自己的登录信息提供给经理，并请他帮忙进行编辑。现在，经理对该员工的演示文稿有了一个 “可变引用”。经理可以做任何他想做的修改，然后把电脑还给他。这很好，因为没有人在看这个演示文稿。

情况二是关于只有不可变引用

情况二 该员工要给100个人做演示。现在这100个人都可以看到该员工的数据。 他们都有一个 “不可改变的引用”，即员工的介绍。这很好，因为他们可以看到它，但没有人可以改变数据。

情况三是有问题的情况

情况三 员工把他的登录信息给了经理 他的经理现在有了一个 “可变引用”。然后员工去给100个人做演示，但是经理还是可以登录。这是不对的，因为经理可以登录，可以做任何事情。也许他的经理会登录电脑，然后开始给他的母亲打一封邮件! 现在这100人不得不看着经理给他母亲写邮件，而不是演示。这不是他们期望看到的。

下面是一个可变借用与不可变借用的例子:

fn main() {
    let mut number = 10;
    let number_ref = &number;
    let number_change = &mut number;
    *number_change += 10;
    println!("{}", number_ref); // ⚠️
}

编译器打印了一个有用的信息来告诉我们问题所在。

error[E0502]: cannot borrow `number` as mutable because it is also borrowed as immutable
 --> src\main.rs:4:25
  |
3 |     let number_ref = &number;
  |                      ------- immutable borrow occurs here
4 |     let number_change = &mut number;
  |                         ^^^^^^^^^^^ mutable borrow occurs here
5 |     *number_change += 10;
6 |     println!("{}", number_ref);
  |                    ---------- immutable borrow later used here

然而，这段代码可以工作。为什么会这样？

fn main() {
    let mut number = 10;
    let number_change = &mut number; // create a mutable reference
    *number_change += 10; // use mutable reference to add 10
    let number_ref = &number; // create an immutable reference
    println!("{}", number_ref); // print the immutable reference
}

它打印出20没有问题。它能工作是因为编译器足够聪明，能够理解我们的代码。它知道我们使用了number_change来改变number，但没有再使用它。所以这里没有问题。我们并没有将不可变和可变引用一起使用。

早期在Rust中，这种代码实际上会产生错误，但现在的编译器更聪明了。它不仅能理解我们输入的内容，还能理解我们如何使用所有的东西。

再谈shadowing

还记得我们说过，shadowing不会破坏一个值，而是屏蔽它吗？现在我们可以用引用来看看这个问题。

fn main() {
    let country = String::from("Austria");
    let country_ref = &country;
    let country = 8;
    println!("{}, {}", country_ref, country);
}

这是打印Austria, 8还是8, 8？它打印的是Austria, 8。首先我们声明一个String，叫做country。然后我们给这个字符串创建一个引用country_ref。然后我们用8来shadowing国家，这是一个i32。但是第一个country并没有被销毁，所以country_ref仍然写着 “Austria”，而不是 “8”。下面是同样的代码，并加了一些注释来说明它的工作原理。

fn main() {
    let country = String::from("Austria"); // Now we have a String called country
    let country_ref = &country; // country_ref is a reference to this data. It's not going to change
    let country = 8; // Now we have a variable called country that is an i8. But it has no relation to the other one, or to country_ref
    println!("{}, {}", country_ref, country); // country_ref still refers to the data of String::from("Austria") that we gave it.
}

函数的引用

引用对函数非常有用。Rust中关于值的规则是:一个值只能有一个所有者。

这段代码将无法工作:

fn print_country(country_name: String) {
    println!("{}", country_name);
}
fn main() {
    let country = String::from("Austria");
    print_country(country); // We print "Austria"
    print_country(country); // ⚠️ That was fun, let's do it again!
}

它不能工作，因为country被破坏了。下面是如何操作的。

• 第一步，我们创建String，称为country。country是所有者。
• 第二步:我们把country给print_country。print_country没有->，所以它不返回任何东西。print_country完成后，我们的String现在已经死了。
• 第三步:我们尝试把country给print_country，但我们已经这样做了。我们已经没有country可以给了。

我们可以让print_country给String回来，但是有点尴尬。

fn print_country(country_name: String) -> String {
    println!("{}", country_name);
    country_name // return it here
}
fn main() {
    let country = String::from("Austria");
    let country = print_country(country); // we have to use let here now to get the String back
    print_country(country);
}

现在打印出来了。

Austria
Austria

更好的解决方法是增加&。

fn print_country(country_name: &String) {
    println!("{}", country_name);
}
fn main() {
    let country = String::from("Austria");
    print_country(&country); // We print "Austria"
    print_country(&country); // That was fun, let's do it again!
}

现在 print_country() 是一个函数，它接受 String 的引用: &String。另外，我们给country一个引用，写作&country。这表示 “你可以看它，但我要保留它”。

现在让我们用一个可变引用来做类似的事情。下面是一个使用可变变量的函数的例子:

fn add_hungary(country_name: &mut String) { // first we say that the function takes a mutable reference
    country_name.push_str("-Hungary"); // push_str() adds a &str to a String
    println!("Now it says: {}", country_name);
}
fn main() {
    let mut country = String::from("Austria");
    add_hungary(&mut country); // we also need to give it a mutable reference.
}

此打印Now it says: Austria-Hungary。

所以得出结论:

• fn function_name(variable: String)接收了String，并拥有它。如果它不返回任何东西，那么这个变量就会在函数里面死亡。
• fn function_name(variable: &String) 借用 String 并可以查看它
• fn function_name(variable: &mut String)借用String，可以更改。

下面是一个看起来像可变引用的例子，但它是不同的。

fn main() {
    let country = String::from("Austria"); // country is not mutable, but we are going to print Austria-Hungary. How?
    adds_hungary(country);
}
fn adds_hungary(mut country: String) { // Here's how: adds_hungary takes the String and declares it mutable!
    country.push_str("-Hungary");
    println!("{}", country);
}

这怎么可能呢？因为mut country不是引用。adds_hungary现在拥有country。(记住，它占用的是String而不是&String)。当你调用adds_hungary的那一刻，它就完全成了country的主人。country与String::from("Austria")没有关系了。所以，adds_hungary可以把country当作可变的，这样做是完全安全的。

还记得我们上面的员工Powerpoint和经理的情况吗？在这种情况下，就好比员工只是把自己的整台电脑交给了经理。员工不会再碰它，所以经理可以对它做任何他想做的事情。

拷贝类型

Rust中的一些类型非常简单。它们被称为拷贝类型。这些简单的类型都在栈中，编译器知道它们的大小。这意味着它们非常容易复制，所以当你把它发送到一个函数时，编译器总是会复制。它总是复制，因为它们是如此的小而简单，没有理由不复制。所以你不需要担心这些类型的所有权问题。

这些简单的类型包括:整数、浮点数、布尔值(true和false)和char。

如何知道一个类型是否实现复制？(实现 = 能够使用)你可以查看文档。例如，这里是 char 的文档:

https://doc.rust-lang.org/std/primitive.char.html

在左边你可以看到Trait Implementations。例如你可以看到Copy, Debug, 和 Display。所以你知道，当你把一个char:

• 当你把它发送到一个函数(Copy)时，它就被复制了。
• 可以用{}打印(Display)
• 可以用{:?}打印(Debug)

fn prints_number(number: i32) { // There is no -> so it's not returning anything
                             // If number was not copy type, it would take it
                             // and we couldn't use it again
    println!("{}", number);
}
fn main() {
    let my_number = 8;
    prints_number(my_number); // Prints 8. prints_number gets a copy of my_number
    prints_number(my_number); // Prints 8 again.
                              // No problem, because my_number is copy type!
}

但是如果你看一下String的文档，它不是拷贝类型。

https://doc.rust-lang.org/std/string/struct.String.html

在左边的Trait Implementations中，你可以按字母顺序查找。A、B、C……C中没有Copy，但是有Clone。Clone和Copy类似，但通常需要更多的内存。另外，你必须用.clone()来调用它—它不会自己克隆。

在这个例子中，prints_country()打印的是国家名称，一个String。我们想打印两次，但我们不能。

fn prints_country(country_name: String) {
    println!("{}", country_name);
}
fn main() {
    let country = String::from("Kiribati");
    prints_country(country);
    prints_country(country); // ⚠️
}

但现在我们明白了这个信息。

error[E0382]: use of moved value: `country`
 --> src\main.rs:4:20
  |
2 |     let country = String::from("Kiribati");
  |         ------- move occurs because `country` has type `std::string::String`, which does not implement the `Copy` trait
3 |     prints_country(country);
  |                    ------- value moved here
4 |     prints_country(country);
  |                    ^^^^^^^ value used here after move

重要的部分是which does not implement the Copy trait。但是在文档中我们看到String实现了Clone的特性。所以我们可以在代码中添加.clone()。这样就创建了一个克隆，然后我们将克隆发送到函数中。现在 country 还活着，所以我们可以使用它。

fn prints_country(country_name: String) {
    println!("{}", country_name);
}
fn main() {
    let country = String::from("Kiribati");
    prints_country(country.clone()); // make a clone and give it to the function. Only the clone goes in, and country is still alive
    prints_country(country);
}

当然，如果String非常大，.clone()就会占用很多内存。一个String可以是一整本书的长度，我们每次调用.clone()都会复制这本书。所以，如果可以的话，使用&来做引用是比较快的。例如，这段代码将&str推送到String上，然后每次在函数中使用时都会进行克隆。

fn get_length(input: String) { // Takes ownership of a String
    println!("It's {} words long.", input.split_whitespace().count()); // splits to count the number of words
}
fn main() {
    let mut my_string = String::new();
    for _ in 0..50 {
        my_string.push_str("Here are some more words "); // push the words on
        get_length(my_string.clone()); // gives it a clone every time
    }
}

它的打印。

It's 5 words long.
It's 10 words long.
...
It's 250 words long.

这就是50个克隆。这里是用引用代替更好:

fn get_length(input: &String) {
    println!("It's {} words long.", input.split_whitespace().count());
}
fn main() {
    let mut my_string = String::new();
    for _ in 0..50 {
        my_string.push_str("Here are some more words ");
        get_length(&my_string);
    }
}

不是50个克隆，而是0个。

无值变量

一个没有值的变量叫做 “未初始化”变量。未初始化的意思是 “还没有开始”。它们很简单:只需写上let和变量名。

fn main() {
    let my_variable; // ⚠️
}

但是你还不能使用它，如果任何东西都没有被初始化，Rust就不会编译。

但有时它们会很有用。一个很好的例子是当:

• 你有一个代码块，而你的变量值就在里面，并且
• 变量需要活在代码块之外。

fn loop_then_return(mut counter: i32) -> i32 {
    loop {
        counter += 1;
        if counter % 50 == 0 {
            break;
        }
    }
    counter
}
fn main() {
    let my_number;
    {
        // Pretend we need to have this code block
        let number = {
            // Pretend there is code here to make a number
            // Lots of code, and finally:
            57
        };
        my_number = loop_then_return(number);
    }
    println!("{}", my_number);
}

这将打印出 100。

你可以看到 my_number 是在 main() 函数中声明的，所以它一直活到最后。但是它的值是在循环里面得到的。然而，这个值和my_number一样长，因为my_number有这个值。而如果你在块里面写了let my_number = loop_then_return(number)，它就会马上死掉。

如果你简化代码，对想象是有帮助的。loop_then_return(number)给出的结果是100，所以我们删除它，改写100。另外，现在我们不需要 number，所以我们也删除它。现在它看起来像这样:

fn main() {
    let my_number;
    {
        my_number = 100;
    }
    println!("{}", my_number);
}

所以说let my_number = { 100 };差不多。

另外注意，my_number不是mut。我们在给它50之前并没有给它一个值，所以它的值一直没有改变。最后，my_number的真正代码只是let my_number = 100;。

集合类型

Rust有很多类型用于创建集合。当你需要在一个地方有多个值时，就可以使用集合。例如，你可以在一个变量中包含你所在国家的所有城市的信息。我们先从数组开始，数组的速度最快，但功能也最少。它们在这方面有点像&str。

数组

数组是方括号内的数据。[]. 数组:

• 不能改变其大小。
• 必须只包含相同的类型。

但是，它们的速度非常快。

数组的类型是:[type; number]。例如，["One", "Two"]的类型是[&str; 2]。这意味着，即使这两个数组也有不同的类型。

fn main() {
    let array1 = ["One", "Two"]; // This one is type [&str; 2]
    let array2 = ["One", "Two", "Five"]; // But this one is type [&str; 3]. Different type!
}

这里有一个很好的提示:要想知道一个变量的类型，你可以通过给编译器下坏指令来 “询问”它。比如说

fn main() {
    let seasons = ["Spring", "Summer", "Autumn", "Winter"];
    let seasons2 = ["Spring", "Summer", "Fall", "Autumn", "Winter"];
    seasons.ddd(); // ⚠️
    seasons2.thd(); // ⚠️ as well
}

编译器说:”什么？seasons没有.ddd()的方法，seasons2也没有.thd()的方法！！”你可以看到:

error[E0599]: no method named `ddd` found for array `[&str; 4]` in the current scope
 --> src\main.rs:4:13
  |
4 |     seasons.ddd(); // 
  |             ^^^ method not found in `[&str; 4]`
error[E0599]: no method named `thd` found for array `[&str; 5]` in the current scope
 --> src\main.rs:5:14
  |
5 |     seasons2.thd(); // 
  |              ^^^ method not found in `[&str; 5]`

所以它告诉你method not found in `[&str; 4]` ，这就是类型。

如果你想要一个数值都一样的数组，你可以这样声明。

fn main() {
    let my_array = ["a"; 10];
    println!("{:?}", my_array);
}

这样就打印出了["a", "a", "a", "a", "a", "a", "a", "a", "a", "a"]。

这个方法经常用来创建缓冲区。例如，let mut buffer = [0; 640]创建一个640个零的数组。然后我们可以将零改为其他数字，以便添加数据。

你可以用[]来索引(获取)数组中的条目。第一个条目是[0]，第二个是[1]，以此类推。

fn main() {
    let my_numbers = [0, 10, -20];
    println!("{}", my_numbers[1]); // prints 10
}

你可以得到一个数组的一个片断(一块)。首先你需要一个&，因为编译器不知道大小。然后你可以使用..来显示范围。

例如，让我们使用这个数组。[1, 2, 3, 4, 5, 6, 7, 8, 9, 10].

fn main() {
    let array_of_ten = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let three_to_five = &array_of_ten[2..5];
    let start_at_two = &array_of_ten[1..];
    let end_at_five = &array_of_ten[..5];
    let everything = &array_of_ten[..];
    println!("Three to five: {:?}, start at two: {:?}, end at five: {:?}, everything: {:?}", three_to_five, start_at_two, end_at_five, everything);
}

记住这一点。

• 索引号从0开始(不是1)
• 索引范围是不包含的(不包括最后一个数字)。

所以[0..2]是指第一个指数和第二个指数(0和1)。或者你也可以称它为 “零点和第一”指数。它没有第三项，也就是索引2。

你也可以有一个包含的范围，这意味着它也包括最后一个数字。要做到这一点。 添加=，写成..=，而不是..。所以，如果你想要第一项、第二项和第三项，可以写成[0..=2]，而不是[0..2]。

向量

就像我们有&str和String一样，我们有数组和向量。数组的功能少了就快，向量的功能多了就慢。(当然，Rust的速度一直都是非常快的，所以向量并不慢，只是比数组慢一点)。类型写成Vec，你也可以直接叫它 “vec”。

向量的声明主要有两种方式。一种是像String一样使用new:

fn main() {
    let name1 = String::from("Windy");
    let name2 = String::from("Gomesy");
    let mut my_vec = Vec::new();
    // If we run the program now, the compiler will give an error.
    // It doesn't know the type of vec.
    my_vec.push(name1); // Now it knows: it's Vec<String>
    my_vec.push(name2);
}

你可以看到Vec里面总是有其他东西，这就是<>(角括号)的作用。Vec<String>是一个有一个或多个String的向量。你还可以在里面有更多的类型。比如说

• Vec<(i32, i32)> 这是一个 Vec 其中每个元素是一个元组。(i32, i32).
• Vec<Vec<String>>这是一个Vec，其中有Vec的Strings。比如说你想把你喜欢的书保存为Vec<String>。然后你再用另一本书来做，就会得到另一个Vec<String>。为了保存这两本书，你会把它们放入另一个Vec中，这就是Vec<Vec<String>>。

与其使用 .push() 让 Rust 决定类型，不如直接声明类型。

fn main() {
    let mut my_vec: Vec<String> = Vec::new(); // The compiler knows the type
                                              // so there is no error.
}

你可以看到，向量中的元素必须具有相同的类型。

另一个创建向量的简单方法是使用 vec! 宏。它看起来像一个数组声明，但前面有 vec!。

fn main() {
    let mut my_vec = vec![8, 10, 10];
}

类型是Vec<i32>。你称它为 “i32的Vec”。而Vec<String>是 “String的Vec”。Vec<Vec<String>>是 “String的Vec的Vec”。

你也可以对一个向量进行分片，就像在数组中一样。

fn main() {
    let vec_of_ten = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    // Everything is the same as above except we added vec!.
    let three_to_five = &vec_of_ten[2..5];
    let start_at_two = &vec_of_ten[1..];
    let end_at_five = &vec_of_ten[..5];
    let everything = &vec_of_ten[..];
    println!("Three to five: {:?},
start at two: {:?}
end at five: {:?}
everything: {:?}", three_to_five, start_at_two, end_at_five, everything);
}

因为Vector比数组慢，我们可以用一些方法让它更快。一个vec有一个容量，也就是给向量的空间。当你在向量上推送一个新的元素时，它会越来越接近容量。然后，如果你超过了容量，它将使其容量翻倍，并将元素复制到新的空间。这就是所谓的重新分配。我们将使用一种名为.capacity()的方法来查看向量的容量，在我们向它添加元素时。

例如，我们将使用名为.capacity()的方法来观察一个向量的容量。

fn main() {
    let mut num_vec = Vec::new();
    println!("{}", num_vec.capacity()); // 0 elements: prints 0
    num_vec.push('a'); // add one character
    println!("{}", num_vec.capacity()); // 1 element: prints 4. Vecs with 1 item always start with capacity 4
    num_vec.push('a'); // add one more
    num_vec.push('a'); // add one more
    num_vec.push('a'); // add one more
    println!("{}", num_vec.capacity()); // 4 elements: still prints 4.
    num_vec.push('a'); // add one more
    println!("{}", num_vec.capacity()); // prints 8. We have 5 elements, but it doubled 4 to 8 to make space
}