《Rust权威指南》
本书由 Rust 核心开发团队编写而成，由浅入深地探讨了 Rust 语言的方方面面。从学习函数、选择数据结构及绑定变量入手，逐步介绍所有权、trait、生命周期、安全保证等高级概念，模式匹配、错误处理、包管理、函数式特性、并发机制等实用工具，以及两个完整的项目开发实战案例。 作为开源的系统级编程语言，Rust 可以帮助你编写出更为快速且更为可靠的软件，在给予开发者底层控制能力的同时，通过深思熟虑的工程设计避免了传统语言带来的诸多麻烦。 本书被视为 Rust 开发工作的必读书目，适合所有希望评估、入门、提高和研究Rust语言的软件开发人员阅读。
[!tip]- 作者简介
Steve Klabnik，Rust文档团队负责人，Rust核心开发者之一，Rust布道者及高产的开源贡献者，此前致力于Ruby等项目的开发。
Carol Nichols，Rust核心团队成员，i32、LLC联合构建者，Rust Belt Rust会议组织者。
毛靖凯，游戏设计师，一直专注于游戏领域研发，曾负责设计和维护了多个商业游戏的基础框架。业余时间活跃于Rust开源社区，并尝试使用Rust来解决游戏领域中的诸多问题。
唐刚，资深开发者，Rustcc社区创始人和维护者之一。目前就职于Cdot Network。使用Rust从事区块链共识协议的开发工作。
沙渺，嵌入式开发者，国内Rust语言社区和Raspberry Pi（树莓派）开发社区早期参与者。负责维护多个RISC-V架构硬件平台的基础函数库。
🗒️我的笔记
主要是看视频 https://www.bilibili.com/video/BV1hp4y1k7SV?p=2&spm_id_from=pageDriver
Rust 特别擅长的领域：
Rust优点：
https://www.rust-lang.org/
安装 in mac
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
更新:
rustup update
卸载Rust
rustup self uninstall
验证安装:
rustc --version
查看本地文档：
rustup doc
rustc main.rs 编译
Rust的缩进是4个空格而不是tab
println! 是个宏。函数是没有!的。
rustc 只适合简单的Rust程序。
复杂的程序得用Cargo。
Cargo是Rust的构建系统和包管理工具。
创建项目 cargo new xxx
cargo build 编译构建项目。会生成target目录，可执行文件就在里面。
cargo run 会编译 并运行项目。
cargo check 检查项目，比build快很多。
为发布构建，得加参数--release
cargo build --release 编译时会进行优化，编译的更慢，生成的执行文件运行的更快。
use std::io; // 引用标准库
fn main() {
println!("猜数!");
println!("测试一个数");
let mut guess = String::new(); // let 默认声明常量。加上mut才是变量。 new类似于静态方法调用。
io::stdin().read_line(&mut guess).expect("无法读取行"); // &表示按引用传递。 expect表示错误处理。 Can
println!("你猜测的数是：{}", guess); //{}是占位符。类似于%s
}
rust中库不叫lib, 而是叫crate.
为了生成随机数，得引用一个叫rand的crate。
直接在Cargo.toml里添加即可。
[dependencies]
rand = "0.3.14"
版本依赖会存到Cargo.lock 中，更新版本时也会更新Cargo.lock
trait 类似于其他语言的接口。
match guess.cmp(&secret_number) {
Ordering::Less=>println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win"),
} // match 类似于其他语言里的switch.
match 类似switch
loop 引入无限循环。break 退出循环。
如果要处理异常，而不是直接panic, 就需要去掉expect, 改成match自己匹配了。
完整的代码：
use std::cmp::Ordering;
use std::io;
use rand::Rng;
fn main() {
println!("猜数!");
let secret_number = rand::thread_rng().gen_range(1,101); // i32 u32 i64
// println!("神秘数字是:{}", secret_number);
loop {
println!("测试一个数");
let mut guess = String::new();
io::stdin().read_line(&mut guess).expect("无法读取行");
println!("你猜测的数是：{}", guess);
// shadow
let guess:u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
match guess.cmp(&secret_number) {
Ordering::Less=>println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {println!("You win");break;},
}
}
}
默认let 声明的是 不可变的。可以指定变量类型，也可自动推导。
要指明可变需要在变量前加mut 修饰符。
const关键词声明，不能用mut修饰符。_分隔。 如 MAX_POINTShadowing(隐藏)
可以声明同名变量 覆盖他。类型可以不一样。一般是类型转换时这么做。
标量类型：一个标量类型代表一个单个的值
复合类型： 将多个值放在一个类型里。
Rust提供两种: 元组(长度固定，元素可以是多种类型)、数组(长度固定，元素类型统一)。
Tuple示例
fn main() {
let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x,y,z) = tup;
println!("{},{},{}", x,y,z); // 通过结构访问
println!("{},{},{}", tup.0,tup.1,tup.2); // 按索引访问
}
数组示例（实际用Vector更多)
数组是分配在栈上的连续内存。
索引越界时 编译会通过，运行时会panic。
申明方式有3种：
let a = [1, 2, 3, 4, 5];let a: [i32; 5] = [1, 2, 3, 4, 5];let a = [3; 5]; // [3,3,3,3,3]关键词是fn , 命名规范为snake case。 入口为main.
参数：
函数签名必须声明类型。
函数体中的语句与表达式
函数的返回值：
注意，表达式不要加’;'号，否则变成了语句。
if
每种情况都叫arm, 必须是bool类型。 按顺序执行。
不用三元运算符。 let number = if condistion { 5 } else {6 }; 这种写法就可以了。
match 类似于其他语言的switch, 处理多分支的。
loop
反复运行。无限循环。 loop 快里最后一个表达式可以返回值。
while条件循环。
for循环遍历集合。(由于其安全、简介。是用的最多的)
fn main() {
let a = [10, 20, 30, 40, 50];
for element in a {
println!("the value is: {}", element);
}
}
Range 协助循环。
fn main() {
for number in (1..4).rev() { // (1..4) 就是 Range 生成[1,2,3] rev()为反转
println!("{}!", number);
}
println!("LIFTOFF!!!");
}
Rust的核心机制。
其他语言要么是手动内存管理，要么是gc 自动管理。
Rust采用了第三种方式
栈内存 vs 堆内存
所有存储在Stack上的数据必须拥有已知的固定的大小。
- 编译时大小未知的数据或运行时大小 可能发生变化的数据 必须存放在heap上。
使用栈内存 性能更高。因为不需要分配内存( 查找可用空间 需要时间)。访问也更快。
所有权解决的问题：
所有权规则
为什么String类型的值可以修改，而字符串字面值却不能修改。
因为他们处理内存的方式不同。
字符串字面值，在编译时就知道它的内容了，其文本内容直接被硬编码到最终的可执行文件里
String类型，为了支持可变性，需要在heap上分配内存来保存编译时未知的文本内容：
drop函数。离开作用域范围时自动调用。
变量与数据交互的方式：
let x=5;let y=x;let s1 = String::from("hello");
let s2 = s1;// 这里 就是移动。。所有权从s1移动到了s2
println!("{}, world!", s1); // 编译通不过。s1被废弃掉了。否则会出现两次释放内存的问题。
![[Pasted image 20220530235851.png]]
2. 克隆(clone)
let s1 = String::from("hello");
let s2 = s1.clone(); // 如下图所示。heap上的内存也复制了一分。
println!("s1 = {}, s2 = {}", s1, s2);
![[Pasted image 20220531000207.png]]
Stack上的数据：复制
由于Stack上复制数据没啥性能消耗。所以不存在heap上的废弃问题。
Copy trait, 可以用于像整数这样完全存放在stack上面的类型（就是大小很明显的值）
如果一个类型实现了Copy这个trait, 那么旧的变量在赋值后仍然可用。
如果一个类型或者该类型的一部分实现了Drop trait, 那么Rust不允许它再去实现Copy trait了
一些拥有Copy trait的类型
所有权和函数
&表示引用： 允许你引用某些值 而 不取得其所有权
![[Pasted image 20220602223830.png]]
如图。s就是s1的引用。
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1); // s1的所有权 不会转移
println!("The length of '{}' is {}.", s1, len);
}
fn calculate_length(s: &String) -> usize {
s.len()
}
我们把引用作为函数参数这个行为叫做借用。
不能修改借用的东西
和变量一样，引用默认是不可变的。
加上mut可以把引用改成可变引用，这样就可以修改了。
不过在特定的作用域内，可变引用只能有一个。
以下三种行为会发生数据竞争：
- 两个或多个指针同事访问同一个数据。
- 至少有一个指针用于写入数据。
- 没有使用任何机制来同步对数据的访问。
可以通过创建新的作用域，来允许非同时的创建多个可变引用。
另一个限制：
不可以同时拥有一个可变引用和一个不变的引用
[!quote]- 悬空引用
悬空指针：一个指针引用了内存中的某个地址，而这块内存可能已经释放并分配给其他人使用了。
在Rust里，编译器可保证引用永远都不是悬空引用；
[!quote]- 引用的规则
在任何给定的时刻，只能满足下列条件之一；
一个可变的引用
任意数量的不可变的引用。
引用必须一致有效
Rust 的另外一种不持有所有权的数据类型： 切片
[!quote]- 字符串切片
字符串切片就是指向字符串中一部分内容的引用。
示例:&a[1..5]
注意：
fn main() {
let mut s = String::from("hello world");
let word = first_word(&s); //这里是不可变引用
s.clear(); // error! 所以这里不能改数据了
println!("the first word is: {}", word);
}
fn first_word(s: &str) -> &str { // &str表示字符串切片。
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[0..i];
}
}
&s[..]
}
例子
// 定义
struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}
fn main() {
// 实例化
let mut user1 = User {
email: String::from("someone@example.com"),
username: String::from("someusername123"),
active: true,
sign_in_count: 1,
};
// 引用字段
user1.email = String::from("anotheremail@example.com");
}
注意: 一旦struct的实例是可变的，那么实例中所有的字段都是可变的
[!quote]- Tuple struct
可定义类似tupe的struct, 叫做tuple struct
整体有名字，但是里面的元素没有名字。
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
fn main() {
let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
}
[!quote]- Unit-Like Struct(没任何字段)
适用于需要在某个类型上实现某个trait, 但是在里面又没有想要存储的数据。
struct数据的所有权
只要struct实例是有效的，那么里面的字段数据也是有效的。
struct里也可以存放引用，需要生命周期
生命周期保证只要struct实例是有效的，那么里面的引用也是有效的。
格式化：
std::fmt::Display {}
std::fmt::Debug
{:?} 单行打印
{:#?} 美化打印
#[derive(Debug)]
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
println!(
"The area of the rectangle is {} square pixels.",
rect1.area()
);
}
方法与函数的不同之处：
[!quote]- 关联函数
可以再impl块里定义不把self作为第一个参数的函数，他们叫关联函数（不是方法）
示例:
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn square(size: u32) -> Rectangle {
Rectangle {
width: size,
height: size,
}
}
}
fn main() {
let sq = Rectangle::square(3); // 调用
}
// 定义
enum IpAddrKind {
V4,
V6,
}
fn main() {
let four = IpAddrKind::V4; // 使用
let six = IpAddrKind::V6;
route(IpAddrKind::V4);
route(IpAddrKind::V6);
}
fn route(ip_kind: IpAddrKind) {}
将数据附加到枚举的变体中
enum IpAddrKind {
V4(String),
V6(String),
}
优点：
不需要额外使用struct
每个变体可以拥有不同的类型以及关联的数据量。
enum IpAddrKind {
V4(u8,u8,u8,u8),
V6(String),
}
[!quote]- Option枚举
定义于标准库中
在Prelude(预导入模块)中
描述了： 某个值可能存在（某种类型） 或不存在的情况
在Rust中没有Null这个概念，而是用Option表达的。
enum Option<T> {
None, // Nome和Some可以直接使用
Some(T),
}
[!tip]-
Option<T>比Null好在哪？
Option<T>和T是不同的类型，不可以把Option<T>直接当做T
若想使用Option<T>中的T, 必须将她转化为T
[!quote]- 强大的控制流运算符-match
允许一个只与一系列模式进行匹配，并执行匹配的模式对应的代码
模式可以是字面值、变量名、通配符…
enum Coin {
Penny,
Nickel,
Dime,
Quarter,
}
fn value_in_cents(coin: Coin) -> u8 {
match coin {
Coin::Penny => 1,
Coin::Nickel => 5,
Coin::Dime => 10,
Coin::Quarter => 25,
}
}
fn main() {}
[!quote]- 绑定值的模式
匹配的分支可以绑定到被匹配对象的部分值。
因此，可以从enum变体中提取值。
匹配Option(T)
#[derive(Debug)]
enum UsState {
Alabama,
Alaska,
// --snip--
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn value_in_cents(coin: Coin) -> u8 {
match coin {
Coin::Penny => 1,
Coin::Nickel => 5,
Coin::Dime => 10,
Coin::Quarter(state) => {
println!("State quarter from {:?}!", state);
25
}
}
}
fn main() {
value_in_cents(Coin::Quarter(UsState::Alaska));
}
[!tip]- match匹配必须穷举所有可能
用_ 表示没列举的可能性。
用于替代 match只关心一种匹配的情况。
fn main() {
let config_max = Some(3u8);
match config_max {
Some(max) => println!("The maximum is configured to be {}", max),
_ => (),
}
}
改成if let
fn main() {
let config_max = Some(3u8);
if let Some(max) = config_max {
println!("The maximum is configured to be {}", max);
}
// 可以有ese 分支 处理其他情况
}
代码组织主要包括：
[!quote]- 模块系统
- Package(包): Cargo的特性，让你构建、测试、共享crate
- Crate(单元包): 一个模块树，它可以产生一个library或可执行文件
- Module(模块)、use: 让你控制代码的组织、作用域、私有路径
- Path(路径): 为struct、function或module等项命名的方式
Cargo的惯例
[!quote]- Crate的作用
将相关的功能组合到一个作用域内，便于在项目间进行共享-防止冲突
::。私有边界
[!quote]- pub
加上pub就变成公有了。
super引用上级
可以使用use关键字将路径导入导作用域内
可以使用相对路径/绝对路径
use的习惯用法：
可用 as 取别名。
use 引入的模块默认是私有的。外部模块无法访问。
加上pub 之后 外部模块也就可以访问了。
使用外部包
标准库也被当做外部包。由于内置了。不需要修改配置文件。但使用的时候还得用use
更多参考 https://download.csdn.net/download/goodparty/86824159?spm=1001.2014.3001.5503