Rust 学习

Rust 官网：https://www.rust-lang.org/zh-CN/

1、Rust 简介

Rust 是一门注重安全（safety）、速度（speed）和并发（concurrency）的现代系统编程语言。Rust 通过内存安全来实现以上目标，但不使用垃圾回收机制（garbage collection, GC）。

Rust 特点

高性能：Rust 速度惊人且内存利用率极高。由于没有运行时和垃圾回收，它能够胜任对性能要求特别高的服务，可以在嵌入式设备上运行，还能轻松和其他语言集成。
可靠性：Rust 丰富的类型系统和所有权模型保证了内存安全和线程安全，让您在编译期就能够消除各种各样的错误。
生产力：Rust 拥有出色的文档、友好的编译器和清晰的错误提示信息，还集成了一流的工具——包管理器和构建工具，智能地自动补全和类型检验的多编辑器支持，以及自动格式化代码等等。

Rust 相关概念

channel：Rust 会发布3个不同版本：stable、beta、nightly。
stable：Rust 的稳定版本，每 6 周发布一次。
beta：Rust 的公开测试版本，将是下一个 stable 版本。
nightly：每天更新，包含以一些实验性的新特性。
toolchain：一套 Rust 组件，包括编译器及其相关工具，并且包含 channel，版本及支持的平台信息。
target：指编译的目标平台，即：编译后的程序在哪种操作系统上运行。
component (组件)：toolchain 是由 component 组成的。查看所有可用和已经安装的组件命令如下：rustup component list。rustup 默认安装的组件：
rustc：Rust 编译器。
rust-std：Rust 标准库。
cargo：包管理和构建工具。
rust-docs：Rust 文档。
rustfmt：用来格式化 Rust 源代码。
clippy：Rust 的代码检查工具。
profile：为了方便对 component 进行管理，使用 profile 定义一组 component。不同的 profile 包含不同的组件，安装 rustup 时有三种 profile 可选，修改 profile 命令如下：rustup set profile minimal
Rustup 是什么：Rustup 是 Rust安装器和版本管理工具。安装 Rust 的主要方式是通过 Rustup 这一工具，它既是一个 Rust 安装器又是一个版本管理工具。Rust 的升级非常频繁。运行 rustup update 获取最新版本的 Rust。文档：https://rust-lang.github.io/rustup/
Cargo 是什么：Cargo 是 Rust 的构建工具和包管理器。安装 Rustup 时会自动安装。Cargo 可以做很多事情：
cargo build 可以构建项目
cargo run 可以运行项目
cargo test 可以测试项目
cargo doc 可以为项目构建文档
cargo publish 可以将库发布到 crates.io。
检查是否安装了 Rust 和 Cargo，可以在终端中运行：cargo --version

下载、安装

下载：https://www.rust-lang.org/tools/install
安装：https://www.rust-lang.org/zh-CN/learn/get-started

默认情况，Rust 依赖 C++ build tools，没有安装也关系。安装过程需要保证网络正常。

在 Rust 开发环境中，所有工具都安装在 ~/.cargo/bin 目录中，可以在这里找到包括 rustc、cargo 和 rustup 在内的 Rust 工具链。在安装过程中，rustup 会尝试配置 PATH，如果 rustup 对 PATH 的修改不生效，可以手动添加路径到 PATH

~/.cargo/bin

~/.rustup/bin

以下是一些常用的命令：

rustup 相关

rustup -h # 查看帮助
rustup show # 显示当前安装的工具链信息
rustup update # 检查安装更新
rustup self uninstall # 卸载
rustup default stable-x86_64-pc-windows-gnu # 设置当前默认工具链

rustup toolchain list # 查看工具链
rustup toolchain install stable-x86_64-pc-windows-gnu # 安装工具链
rustup toolchain uninstall stable-x86_64-pc-windows-gnu # 卸载工具链
rustup toolchain link <toolchain-name> "<toolchain-path>" # 设置自定义工具链

rustup override list # 查看已设置的默认工具链
rustup override set <toolchain> --path <path> # 设置该目录以及其子目录的默认工具链
rustup override unset --path <path> # 取消目录以及其子目录的默认工具链

rustup target list # 查看目标列表
rustup target add <target> # 安装目标
rustup target remove <target> # 卸载目标
rustup target add --toolchain <toolchain> <target> # 为特定工具链安装目标

rustup component list # 查看可用组件
rustup component add <component> # 安装组件
rustup component remove <component> # 卸载组件

rustc 相关

rustc --version # 查看rustc版本

cargo 相关

cargo --version # 查看cargo版本
cargo new <project_name> # 新建项目
cargo build # 构建项目
cargo run # 运行项目
cargo check # 检查项目
cargo -h # 查看帮助

配置工具链安装位置

在系统环境变量中添加如下变量：
CARGO_HOME 指定 cargo 的安装目录
RUSTUP_HOME 指定 rustup 的安装目录
默认分别安装到用户目录下的.cargo 和.rustup 目录

配置国内镜像

配置 rustup 国内镜像。在系统环境变量中添加如下变量（选一个就可以，可以组合）：

# 清华大学
RUSTUP_DIST_SERVER：https://mirrors.tuna.tsinghua.edu.cn/rustup
RUSTUP_UPDATE_ROOT：https://mirrors.tuna.tsinghua.edu.cn/rustup/rustup

# 中国科学技术大学
RUSTUP_DIST_SERVER：https://mirrors.ustc.edu.cn/rust-static
RUSTUP_UPDATE_ROOT：https://mirrors.ustc.edu.cn/rust-static/rustup

配置 cargo 国内镜像。在 cargo 安装目录下新建 config 文件（注意 config 没有任何后缀），文件内容如下：

[source.crates-io]
registry = "https://github.com/rust-lang/crates.io-index"
replace-with = 'tuna'

# 清华大学
[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"

# 中国科学技术大学
[source.ustc]
registry = "git://mirrors.ustc.edu.cn/crates.io-index"
# 设置代理
[http]
proxy = "127.0.0.1:8889"
[https]
proxy = "127.0.0.1:8889"

Windows 交叉编译 Linux 程序。目标服务器是 Linux(CentOS 7) 64bit, 所以我们添加的 target 应该是x86_64-unknown-linux-gnu(动态依赖) 或者x86_64-unknown-linux-musl（静态依赖）

动态依赖：目标服务器需要包含动态依赖的相关库（用户共享库）
静态依赖，目标服务器不需要包含相应的库，但是打包文件会更大些

1). 添加需要的 target
rustup target add x86_64-unknown-linux-musl
2). 在 cargo 安装目录下新建 config 文件（注意 config 没有任何后缀），添加的文件内容如下：
[target.x86_64-unknown-linux-musl]
linker = "rust-lld"
3). 构建
cargo build --target x86_64-unknown-linux-musl

示例：

创建新项目

用 Cargo 创建一个新项目。在终端中执行：cargo new hello-rust，会生成一个名为 hello-rust 的新目录，其中包含以下文件：

Cargo.toml 为 Rust 的清单文件。其中包含了项目的元数据和依赖库。
src/main.rs 为编写应用代码的地方。

进入新创建的目录中，执行命令运行此程序：cargo run

添加依赖

现在来为程序添加依赖。可以在 crates.io，即 Rust 包的仓库中找到所有类别的库。在 Rust 中通常把 "包" 称作 "crates"。在本项目中，使用了名为 ferris-says 的库。

在 Cargo.toml 文件中添加以下信息（从 crate 页面上获取）：

[dependencies]
ferris-says = "0.3.1"

下载依赖

运行：cargo build ， Cargo 就会安装该依赖。运行 build 会创建一个新文件 Cargo.lock，该文件记录了本地所用依赖库的精确版本。

使用依赖

使用该依赖库：可以打开 main.rs，删除其中所有的内容（它不过是个示例而已），然后在其中添加下面这行代码：use ferris_says::say;

这样就可以使用 ferris-says crate 中导出的 say 函数了。

完整 Rust 示例

现在用上面的依赖库编写一个小应用。在 main.rs 中添加以下代码：

use ferris_says::say; // from the previous step
use std::io::{stdout, BufWriter};

fn main() {
    let stdout = stdout();
    let message = String::from("Hello fellow Rustaceans!");
    let width = message.chars().count();

    let mut writer = BufWriter::new(stdout.lock());
    say(&message, width, &mut writer).unwrap();
}

保存完毕后，执行命令运行程序：cargo run

成功执行后，会打印一个字符形式的螃蟹图案。

Ferris ( 费理斯 ) 是 Rust 社区的非官方吉祥物。

2、Rust 相关文档

：https://www.rust-lang.org/zh-CN/learn

核心文档

以下所有文档都可以用 rustup doc 命令在本地阅读，它会在浏览器中离线打开这些资源！

标准库

详尽的 Rust 标准库 API 手册。：https://doc.rust-lang.org/std/index.html

版本指南

Rust 版本指南。：https://doc.rust-lang.org/edition-guide/index.html

CARGO 手册

Rust 的包管理器和构建系统。：https://doc.rust-lang.org/cargo/index.html

RUSTDOC 手册

学习如何为 crate 编写完美的文档。：https://doc.rust-lang.org/rustdoc/index.html

RUSTC 手册

熟悉 Rust 编译器中可用的选项。：https://doc.rust-lang.org/rustc/index.html

编译错误索引表

深入解释遇到的编译错误。：https://doc.rust-lang.org/error_codes/error-index.html

Rust 程序

命令行程序

用 Rust 构建高效的命令行应用。：https://rust-cli.github.io/book/index.html

WEBASSEMBLY 手册

通过 WebAssembly 用 Rust 构建浏览器原生的库。：https://rustwasm.github.io/docs/book/

嵌入式手册

Rust 编写嵌入式程序。：https://doc.rust-lang.org/stable/embedded-book/

3、Rust 程序设计语言

英文文档：https://doc.rust-lang.org/book/

中文文档：https://kaisery.github.io/trpl-zh-cn/

《Rust 程序设计语言》被亲切地称为“圣经”。给出了 Rust 语言的概览。在阅读的过程中构建几个项目，读完后，就能扎实地掌握 Rust 语言。

1. 入门指南
1. 1.1. 安装
2. 1.2. Hello, World!
3. 1.3. Hello, Cargo!
2. 写个猜数字游戏
3. 常见编程概念
1. 3.1. 变量与可变性
2. 3.2. 数据类型
3. 3.3. 函数
4. 3.4. 注释
5. 3.5. 控制流
4. 认识所有权
1. 4.1. 什么是所有权？
2. 4.2. 引用与借用
3. 4.3. Slice 类型
5. 使用结构体组织相关联的数据
1. 5.1. 结构体的定义和实例化
2. 5.2. 结构体示例程序
3. 5.3. 方法语法
6. 枚举和模式匹配
1. 6.1. 枚举的定义
2. 6.2. match 控制流结构
3. 6.3. if let 简洁控制流
7. 使用包、Crate 和模块管理不断增长的项目
1. 7.1. 包和 Crate
2. 7.2. 定义模块来控制作用域与私有性
3. 7.3. 引用模块项目的路径
4. 7.4. 使用 use 关键字将路径引入作用域
5. 7.5. 将模块拆分成多个文件
8. 常见集合
1. 8.1. 使用 Vector 储存列表
2. 8.2. 使用字符串储存 UTF-8 编码的文本
3. 8.3. 使用 Hash Map 储存键值对
9. 错误处理
1. 9.1. 用 panic! 处理不可恢复的错误
2. 9.2. 用 Result 处理可恢复的错误
3. 9.3. 要不要 panic!
10. 泛型、Trait 和生命周期
1. 10.1. 泛型数据类型
2. 10.2. Trait：定义共同行为
3. 10.3. 生命周期确保引用有效
11. 编写自动化测试
1. 11.1. 如何编写测试
2. 11.2. 控制测试如何运行
3. 11.3. 测试的组织结构
12. 一个 I/O 项目：构建命令行程序
1. 12.1. 接受命令行参数
2. 12.2. 读取文件
3. 12.3. 重构以改进模块化与错误处理
4. 12.4. 采用测试驱动开发完善库的功能
5. 12.5. 处理环境变量
6. 12.6. 将错误信息输出到标准错误而不是标准输出
13. Rust 中的函数式语言功能：迭代器与闭包
1. 13.1. 闭包：可以捕获其环境的匿名函数
2. 13.2. 使用迭代器处理元素序列
3. 13.3. 改进之前的 I/O 项目
4. 13.4. 性能比较：循环对迭代器
14. 更多关于 Cargo 和 Crates.io 的内容
1. 14.1. 采用发布配置自定义构建
2. 14.2. 将 crate 发布到 Crates.io
3. 14.3. Cargo 工作空间
4. 14.4. 使用 cargo install 安装二进制文件
5. 14.5. Cargo 自定义扩展命令
15. 智能指针
1. 15.1. 使用Box<T> 指向堆上数据
2. 15.2. 使用Deref Trait 将智能指针当作常规引用处理
3. 15.3. 使用Drop Trait 运行清理代码
4. 15.4. Rc<T> 引用计数智能指针
5. 15.5. RefCell<T> 与内部可变性模式
6. 15.6. 引用循环会导致内存泄漏
16. 无畏并发
1. 16.1. 使用线程同时地运行代码
2. 16.2. 使用消息传递在线程间通信
3. 16.3. 共享状态并发
4. 16.4. 使用Sync 与 Send Traits 的可扩展并发
17. Rust 的面向对象编程特性
1. 17.1. 面向对象语言的特点
2. 17.2. 为使用不同类型的值而设计的 trait 对象
3. 17.3. 面向对象设计模式的实现
18. 模式与模式匹配
1. 18.1. 所有可能会用到模式的位置
2. 18.2. Refutability（可反驳性）: 模式是否会匹配失效
3. 18.3. 模式语法
19. 高级特征
1. 19.1. 不安全的 Rust
2. 19.2. 高级 trait
3. 19.3. 高级类型
4. 19.4. 高级函数与闭包
5. 19.5. 宏
20. 最后的项目：构建多线程 web server
1. 20.1. 建立单线程 web server
2. 20.2. 将单线程 server 变为多线程 server
3. 20.3. 优雅停机与清理
21. 附录
1. 21.1. A - 关键字
2. 21.2. B - 运算符与符号
3. 21.3. C - 可派生的 trait
4. 21.4. D - 实用开发工具
5. 21.5. E - 版本
6. 21.6. F - 本书译本
7. 21.7. G - Rust 是如何开发的与 “Nightly Rust”