1.包管理工具Cargo
新建项目
1）打开 cmd 输入命令查看 cargo 版本
bash
cargo --version2） 使用 cargo new 项目名
在文件夹，按 shift + 鼠标右键 ，打开命令行，运行如下命令，即可创建一个新项目
bash
cargo new hello-rustCargo 已经帮我们创建好默认项目了，还创建了个 git 的本地仓库，还有一些配置文件。
src/main.rs: 为编写应用代码的地方
Cargo.toml: 项目的配置文件，其中包括项目名，依赖等内容。
Cargo.lock: 如果项目编译正常，会生成一个Cargo.lock文件，这个文件记录项目依赖的实际版本。不需要碰这个文件，让 Cargo 处理它就行了。
.gitignore: 是个git忽略文件列表，在上传到git时，并不是所有文件都要上传到github的。同时这也提醒我们，cargo为我们创建了一个github仓库。
3）在终端中构建项目
bash
cargo build4）编译并运行
bash
cargo run5）可以指定版本管理系统，--vcs=git，可选参数有 git, hg, pijul, fossil, none
bash
cargo new --vcs=git使用 --vcs 参数指定或者切换版本管理系统，如果文件夹已经有了仓库了，那么默认就不会创建仓库了。
6）检查代码的工具，该命令快速检查代码确保其可以编译，但并不产生可执行文件：
bash
cargo check7）发布项目
发布项目时，可以以release构建项目，以让 Rust 代码运行的更快，不过启用这些优化也需要消耗更长的编译时间。
bash
cargo build --release Debug是为了开发，你需要经常快速重新构建；
Release是为用户构建最终程序，它们不会经常重新构建，并且希望程序运行得越快越好。
编写第一个rust程序
Cargo.toml 文件是一个管理项目配置的文件，包括项目依赖等相关配置
在 [dependencies] 区域中添加依赖：ferris-says = "0.3.1"，这个根据当前的版本来写版本号
终端运行
bash
cargo build即完成添加依赖
在main.rs 中编写代码
rust
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.as_str(), width, &mut writer).unwrap();
}原文代码似乎不适用于当前版本，say() 函数第一个参数期望的类型是 &str（字符串切片类型），而不是 &[u8]（字节切片类型）。可以使用 as_str() 方法来实现，而不是 as_bytes()。
编译并运行代码
powershell
cargo run运行结果如下
格式化输出
rust
fn main() {
// 1
println!("{} days", 31); // {}相当于c++的%d这种占位符
println!("{} day {} month", 4, 3); // 使用两个占位符
// 2
println!("{} world", "hello"); // 字符串类型替换掉占位符，{}可以表示作为任意类型的占位符，即通用
// 3
println!("{0} 是 张三， {1} 是 李四，张三不是 {1}, 李四不是 {0}", "张三", "李四"); // 占位符里的序号i，由 ，后的序号为i的变量替换
// 4 用参数名代替序号
println!("{subject} {verb} {object}", object = "你", subject = "我", verb = "爱");
// 5 输出带有指定格式占位符的字符串
// :前表示的是参数的序号，即,后边的参数序号
// 后边表示以进制格式，{x}: 十六进制；{o}: 八进制；{b}: 二进制
// 代码中的字符串换行，打印出来也是换行的
println!("
{} 的二进制表示是： {0:b}
{0} 的八进制表示是： {0:o}
{0} 的16进制表示是： {0:x}", 10);
// 6 指定宽度对齐
// 左对齐
println!("{number:<width$}", number = 1000, width = 6);
// <width$ 是一个格式说明符，其中 width 是通过 $ 符号引用的命名参数，表示宽度为 6。< 则表示左对齐
// 右对齐，一共4位，左边两个空白格
println!("{number:>width$}", number = 1000, width = 6);
let name = "Alice";
println!("{:15}", name); // 默认情况下左对齐，宽度为10
println!("{:<15}", name); // 左对齐，宽度为10
println!("{:^15}", name); // 居中对齐，宽度为10
println!("{:>15}", name); // 右对齐，宽度为10
// 7 数字输出缺位补0
println!("{number:>0width$}", number = 1, width = 6);
}2.变量和数据类型
rust
fn main() {
// 1.定义变量（不可变）
let x = 5;
let y = 5.0;
let str1 = "hello_1";
let str2 = String::from("hello_2");
println!("{0} {1} {2} {3}", x, y, str1, str2);
// 2.定义变量时指定类型
let x: i32 = 5;
let y: f64 = 5.0;
// let str1: String = "hello_1"; // 错误的，"" 类型的字符串是 &str，而不是 QString
let str1: &str = "hello";
println!("{0} {1} {2}", x, y, str1);
// 3.定义可变变量
let mut x: i32 = 5;
println!("{}", x);
x = 10;
println!("{}", x);
}Shadowing
可以使用相同的名字声明新的变量，新的变量就会 shadow 之前声明的同名变量
基本数据类型
数值类型又分为整数型、浮点数、序列类型。
整型
| 长度 | 有符号 | 无符号 | 无符号范围 |
|---|---|---|---|
| 8-bit | i8 | u8 | 0~127 |
| 16-bit | i16 | u16 | 0 ~ 255 |
| 32-bit | i32 | u32 | 0 ~4294967295 |
| 64-bit | i64 | u64 | |
| arch | isize | usize |
其他长度也类似，8-bit、16-bit、128-bit
arch 长度根据计算机的架构决定，64位计算机就是64 ...
rust
const MAX_POINTS = 100_000; // 可以使用下划线增强可读性
Byte类型（仅支持 u8），例子：b'A'浮点型
| 长度 | 类型 |
|---|---|
| 32-bit | f32 |
| 64-bit | f64 |
所有的浮点型都是有符号的
默认使用的浮点是64位的
rust
fn main() {
let x = 2.0; // f64
let y: f32 = 3.0; // f32
}字符类型
字符使用的是单引号，字符串使用的是双引号
Rust的char类型是Unicode的，支持更多的字符，占4字节
rust
let x = 'z';
let y: char = 'c';
let heart_eyed_cat = '😻';
let love_message = "I love Rust! 😍";
println!("{0} {1} {2}\n{3}", x, y, heart_eyed_cat, love_message);布尔类型
rust
fn main() {
let t = true;
let f: bool = false; // 指定变量类型
}复合类型
复合类型可以将多个值组合成一个类型。Rust 有两个原生的复合类型：元组（tuple）和数组（array）。
元组
元组是一个将多个其他类型的值组合进一个复合类型的主要方式。可以将多个不同类型的值进行复合，但是元组长度固定：一旦声明，其长度不会增大或缩小。
rust
// 1.定义元组，小括号
let tup1 = (500, 6.4, 1);
let tup2: (i32, f32, bool) = (500, 6.4, false);
// 2.解构
let (x, y, z) = tup1;
let (a, b, c) = tup2;
println!("{} {1} {2}", x, y, z);
println!("{} {1} {2}", a, b, c);
// 3.取出元素第一个元素，下标和数组一样从0开始，用.运算符取出
let x1 = tup1.0;
println!("{}", x1);数组
与元组不同，数组中的每个元素的类型必须相同。Rust 中的数组与一些其他语言中的数组不同，Rust中的数组长度是固定的。
rust
// 1
let a = [1, 2, 3, 4, 5]; // 中括号
let b = ["first", "second", "third", "fourth"];
let c:[i32, 5] = [1, 2, 3, 4, 5];
// 2. [数组初始值 ; 数组长度]
let d = [3; 5]; // 创建了一个数组d，其中有5个元素，这五个元素都是整数3
// 访问数组元素和其他语言一样，使用索引
// 数组访问越界编译可能不会提示，在运行时会 RE
println!("{} {1} {2} {3} {4}", d[0], d[1], d[2], d[3], d[4]);数组的用处：如果你想让你的数据存放在 stack 上，或者想保证有固定数量的元素。
常量
常量与不可变量是类似的，但是是不同的。常量(constants) 是绑定到一个名称的不允许改变的值。
不可变变量（Immutable Variables）：
- 不可变变量是在运行时确定的，一旦被绑定了就不能再改变值的变量。
- 在Rust中，所有变量默认都是不可变的，如果需要使变量可变，可以使用mut关键字来标记变量为可变的。
- 不可变变量一旦绑定了值，就不能再修改为其他值，但可以使用遮蔽（shadowing）来重新绑定新的值。
- 不可变变量在其作用域内都不能被修改，但可以被重新绑定。
总的来说，常量是编译时就确定的值，而不可变变量是运行时确定的值，在程序执行过程中可以进行遮蔽和重新绑定。
常量（Constants）：
- 常量是在编译时就已经确定的、不可变的值。
- 常量必须在声明时就被显式地标记为const关键字，并且必须注明其类型
- 常量的值在整个程序执行期间都不能改变。
- 常量可以在任何作用域中声明，包括全局作用域和局部作用域。
- 常量的名称使用全大写字母，单词之间用下划线分隔。
rust
fn main() {
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
}变量只有初始化了才可以使用
rust
let x: i32; // 未初始化，但被使用，error
let y: i32; // 未初始化，也未被使用，warning
println!("x is equal to {}", x);变量解构
rust
let (mut x, y) = (1, 2);
x += 2;
println!("{} {1}", x, y);parse 解析类型
使用 parse() 函数解析类型时，要标注需要转换成哪种类型
使用 trim() 去掉字符串首尾的空格
rust
let mut space = " 1";
let x:i32 = space.trim().parse().expect("not a number");
println!("{} {}",space, x);
space = "00001";
let x:i32 = space.parse().expect("not a number");
println!("{} {}",space, x);3.函数与流程控制
与 c 语言不同，rust 对函数声明的位置没有要求
rust
fn main() {
function(10); // argument
}
fn function(x: i32) { // parameter，必须指明所有变量的类型
println!("{}", x);
}语句和表达式
表达式是有返回值的，而语句没有
rust
let x = 10; // 语句
x + 10 // 表达式，如果表达式后边加上";"，那么就变成语句了，就没有返回值了
rust
fn main() {
let y = {
let x = 1;
x + 3 // {}代码块的返回值是最后一个表达式
// 如果加上分号，代码块中就没有表达式了，就不会返回值了
};
println!("{}", y);
}函数的返回值
- 在 rust 中，返回值就是函数体里边最后一个表达式的值
- 若想提前返回，需要使用 return 关键字，并指定一个值，返回值时必须加
{} - 在 -> 符号后边声明函数返回值的类型，但是不可以为返回值命名
rust
fn main() {
let x = puls_five(5);
println!("{}", x);
}
fn puls_five(x: i32) -> i32 {
if x == 5 {
return x;
// 这里是使用 return 关键字返回值，";" 加不加都不影响结果
}
x + 5
}if 表达式
if的条件必须是bool类型，与 c++ 等其他语言不同，rust 不会将其他条件转换成bool- if 表达式中，与条件相关联的代码块叫做分支 （arm）
当使用较多的 else if 时，最好使用 match 来重构
由于 if 是表达式，因此可以将 if 表达式的返回值赋值给变量，但是所有情况下 返回值的类型必须相同 ，i32 和 i64 这种情况也是不可以的
rust
fn main() {
let flag = true;
let number: i32 = if flag {5} else {6};
println!("{}", number);
}循环
loop
rust
fn main() {
let mut counter = 0;
let result = loop {
counter += 1;
if counter == 10 {
break counter * 2; // 当相等时，使用 break 关键字返回值 counter * 2
// 这里是使用 break 关键字返回值，";" 加不加都不影响结果
}
};
println!("{}", result);
}循环标签
在多个循环之间消除歧义
如果存在嵌套循环，break 和 continue 应用于此时最内层的循环。你可以选择在一个循环上指定一个 循环标签（loop label），然后将标签与 break 或 continue 一起使用，使这些关键字应用于已标记的循环而不是最内层的循环。
rust
fn main() {
let mut count = 0;
'counting_up: loop {
println!("count = {count}");
let mut remaining = 10;
loop {
println!("remaining = {remaining}");
if remaining == 9 {
break;
}
if count == 2 {
break 'counting_up;
}
remaining -= 1;
}
count += 1;
}
println!("End count = {count}");
}
// 输出
/*
count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2
*/while
rust
fn main() {
let mut counter = 3;
while counter != 0 {
println!("{}", counter);
counter = counter - 1;
}
println!("finish");
}while 遍历数组
rust
fn main() {
let a = [1, 2, 3, 4, 5];
let mut index = 0;
while index < 5 {
println!("{}", a[index]);
index += 1;
}
}for
更好的遍历数组的方式是 for，每次循环不需要判断条件
rust
fn main() {
let a = [11, 22, 33, 44, 55];
// iter() 返回一个迭代器，这个迭代器是对 v 的引用，因此不会转移所有权
for x in a.iter() {
println!("{}", x);
}
// 直接遍历 a 似乎没有问题
// 但是如果是 vector，for x in v {} 这样遍历后，里边元素的所有权就被转移了
// Range
// rev方法可以反转 Range
for x in (1..=5).rev() {
println!("{}", x);
}
for x in 0..5 {
println!("{}", a[x]);
}
}---------杂项
区间，Range
rust
// 1. a..=b ---> [a,b]
// 2. a..b ---> [a,b)
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("神秘数是：{}", secret_number);可变引用和解引用
rust
fn main() {
// 栈上的基本数据类型
let mut x: i32 = 10;
let d: &mut i32 = &mut x; // 可变引用只能定义在可变的变量的基础上
*d += 10; // 对可变引用解引用才能修改值
println!("{d}");
// 堆上的可变数据类型
let mut str: String = String::from("hello world!!!");
let s: &mut String = &mut str;
s.push_str("\neveryone");
println!("{s}");
}4.所有权
认识所有权
所有权（系统）是 Rust 最为与众不同的特性，对语言的其他部分有着深刻含义。它让 Rust 无
需垃圾回收（garbage collector）即可保障内存安全，因此理解 Rust 中所有权如何工作是十
分重要的。
栈（Stack）与堆（Heap）
- 栈和堆都是代码在运行时可供使用的内存，但是它们的结构不同。栈中的所有数据都必须占用已知且固定的大小。在编译时大小未知或大小可能变化的数据，要改为存储在堆上。 堆是缺乏组织的：当向堆放入数据时，你要请求一定大小的空间。内存分配器（memory allocator）在堆的某处找到一块足够大的空位，把它标记为已使用，并返回一个表示该位置地址的 指针（pointer）。这个过程称作 在堆上分配内存（allocating on the heap），有时简称为 "分配"（allocating）。（将数据推入栈中并不被认为是分配）。因为指向放入堆中数据的指针是已知的并且大小是固定的，你可以将该指针存储在栈上，不过当需要实际数据时，必须访问指针。
- 入栈比在堆上分配内存要快，因为（入栈时）分配器无需为存储新数据去搜索内存空间；其位置总是在栈顶。相比之下，在堆上分配内存则需要更多的工作，这是因为分配器必须首先找到一块足够存放数据的内存空间，并接着做一些记录为下一次分配做准备。
- 访问堆上的数据比访问栈上的数据慢，因为必须通过指针来访问。现代处理器在内存中跳转越少就越快（缓存）。处理器在处理的数据彼此较近的时候（比如在栈上）比较远的时候（比如可能在堆上）能更好的工作。
- 跟踪哪部分代码正在使用堆上的哪些数据，最大限度的减少堆上的重复数据的数量，以及清理堆上不再使用的数据确保不会耗尽空间，这些问题正是所有权系统要处理的。一旦理解了所有权，就不需要经常考虑栈和堆了，不过明白了所有权的主要目的就是管理堆数据，能够帮助解释为什么所有权要以这种方式工作。
所有权规则
- Rust 中的每一个值都有一个 所有者（owner）。
- 值在任一时刻有且只有一个所有者。
- 当所有者（变量）离开作用域，这个值将被丢弃。
String 类型
字符串字面值：我们在编译时就知道其内容，所以文本被直接硬编码进最终的可执行文件中，这使得字符串字面值快速且高效。
String 类型管理被分配到堆上的数据，所以能够存储在编译时未知大小的文本。可以使用 from 函数基于字符串字面值来创建 String
rust
let s = String::from("hello");内存与分配
对于 String 类型，为了支持一个可变，可增长的文本片段，需要在堆上分配一块在编译时未知大小的内存来存放内容。这意味着：
- 必须在运行时向内存分配器（memory allocator）请求内存。
- 需要一个当我们处理完 String 时将内存返回给分配器的方法。
第一部分由我们完成：当调用 String::from 时，它的实现 (implementation) 请求其所需的内
存。这在编程语言中是非常通用的。
然而，第二部分实现起来就各有区别了。在有垃圾回收（garbage collector，GC）的语言中，
GC 记录并清除不再使用的内存，而我们并不需要关心它。在大部分没有 GC 的语言中，识别
出不再使用的内存并调用代码显式释放就是我们的责任了，跟请求内存的时候一样。从历史的
角度上说正确处理内存回收曾经是一个困难的编程问题。如果忘记回收了会浪费内存。如果过
早回收了，将会出现无效变量。如果重复回收，这也是个 bug。我们需要精确的为一个 allocate 配对一个 free 。
Rust 采取了一个不同的策略：内存在拥有它的变量离开作用域后就被自动释放。
rust
fn main() {
{
let s = String::from("hello"); // 从此处起，s 是有效的
// 使用 s
} // 此作用域已结束，
// s 不再有效
}当变量 s 离开作用域，Rust 为我们调用 drop 函数 ，在这里 String 的作者可以放置释放内存的代码。Rust 在结尾的 } 处自动调用 drop 。这与 C++ 的 RAII 模式类似
移动（旧变量不可用）
rust
// String 类型
fn main() {
let s1 = String::from("hello");
let s2 = s1;
// 变量 s2 的内存表现，它有一份 s1 指针、长度和容量的拷贝
println!("{}", s1); // 报错，s1已经无效，不能使用
// 这个过程看起来和浅拷贝差不多，但还是有点区别，rust会认为原来的s1已经失效
// 因此 Rust 不需要在 s1 离开作用域后清理任何东西，避免了二次释放的错误
}克隆
rust
fn main() {
let s1 = String::from("hello");
let s2 = s1.clone(); // 和深拷贝一样的效果
println!("{}", s2);
}只在栈上的数据：拷贝
rust
// 具有 cpoy trait 的类型
// 将 5 绑定到 x ，接着生成一个值 x 的拷贝并绑定到 y
fn main() {
let x = 5;
let y = x;
}- 如果复合类型的元素都是具有
cpoy trait的，那么这个复合类型也具有cpoy trait属性 - Rust 不允许自身或其任何部分实现了 Drop trait 的类型使用 Copy trait
如下是一些 Copy 的类型：
- 所有整数类型，比如 u32 。
- 布尔类型，bool ，它的值是 true 和 false 。
- 所有浮点数类型，比如 f64 。
- 字符类型，char 。
- 元组，当且仅当其包含的类型也都实现 Copy 的时候。比如，(i32, i32) 实现了 Copy ，但(i32, String) 就没有。
所有权与函数
将值传递给函数与给变量赋值的原理相似。向函数传递值可能会移动或者复制，就像赋值语句一样。
rust
fn main() {
let s = String::from("hello"); // s 进入作用域
takes_ownership(s); // s 的值移动(所有权转移)到函数里
// ... 所以到这里不再有效
let x = 5; // x 进入作用域
makes_copy(x); // x的值拷贝到函数makes_copy中
// 在后面可继续使用 x
}
fn takes_ownership(some_string: String) { // some_string 进入作用域
println!("{}", some_string);
} // 这里，some_string 移出作用域并调用 `drop` 方法
// some_string 占用的内存被释放
fn makes_copy(some_integer: i32) { // some_integer（x的副本） 进入作用域
println!("{}", some_integer);
} // 这里，some_integer 移出作用域，没有特殊之处返回值与作用域
返回值也可以转移所有权
rust
fn main() {
// gives_ownership 将返回值的所有权转移给 s1
let s1 = gives_ownership();
let s2 = String::from("hello"); // s2 进入作用域
// s2 被移动到takes_and_gives_back 中，它也将返回值移给 s3
let s3 = takes_and_gives_back(s2);
}
// s3 离开作用域并被丢弃
// s2 也移出作用域，但已被移走，所以什么也不会发生
// s1 离开作用域并被丢弃
fn gives_ownership() -> String {
// 将返回值移动给调用它的函数
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 并移交所有权
}变量的所有权 总是遵循相同的模式：将值赋给另一个变量时移交所有权。当持有堆中数据值的变量离开作用域时，其值将通过 drop 被清理掉，除非数据被移动为另一个变量所有。
（引用，References）如何仅使用变量的值而不获取其所有权
rust
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 是 String 的引用
s.len()
}
// s 离开了作用域，但因为它并不拥有引用值的所有权，所以什么也不会发生
我们将创建一个引用的行为称为 借用（borrowing）。
正如变量默认是不可变的，引用也一样，（默认）不允许修改引用的值。
如果要改变引用的值，就需要可变引用作为参数，在 & 后增加 mut 关键字
rust
fn main() {
let mut s = String::from("hello");
change(&mut s);
}
fn change(some_string: &mut String) {
some_string.push_str(", world");
}（1）rust为了避免数据竞争，不允许对一个已经有可变引用的变量再次创建可变引用，如下：
rust
fn main() {
let mut s = String::from("hello");
let r1 = &mut s;
let r2 = &mut s;
println!("{}, {}", r1, r2);
}可以使用大括号来创建一个新的作用域，以允许拥有多个可变引用，只是不能 同时拥有：
rust
fn main() {
let mut s = String::from("hello");
{
let r1 = &mut s;
} // r1 在这里离开了作用域，所以我们完全可以创建一个新的引用
let r2 = &mut s;
}（2）Rust 不允许同时使用可变与不可变引用
rust
fn main() {
let mut s = String::from("hello");
let r1 = &s; // 没问题
let r2 = &s; // 没问题
// 多个不可变引用是可以的，但不能同时存在可变引用
let r3 = &mut s; // 大问题
println!("{}, {}, and {}", r1, r2, r3);
}（3）一个引用的作用域 ：从声明的地方开始一直持续到最后一次使用为止。例如，因为最后一次使用不可变引用（println! )，发生在声明可变引用之前，所以如下代码是可以编译的：
rust
fn main() {
let mut s = String::from("hello");
let r1 = &s; // 没问题
let r2 = &s; // 没问题
println!("{} and {}", r1, r2);
// 此位置之后 r1 和 r2 不再使用
let r3 = &mut s; // 没问题
println!("{}", r3);
}悬垂引用
Rust 中编译器确保引用永远也不会变成悬垂状态：当你拥有一些数据的引用，编译器确保数据不会在其引用之前离开作用域。
rust
fn main() {
let reference_to_nothing = dangle();
}
fn dangle() -> &String { // dangle 返回一个字符串的引用
let s = String::from("hello"); // s 是一个新字符串
&s // 返回字符串 s 的引用
} // 这里 s 离开作用域并被丢弃。其内存被释放。
// 危险！这里的解决方法是直接返回 String ：
rust
fn main() {
let string = no_dangle();
}
fn no_dangle() -> String {
let s = String::from("hello");
s
}这样就没有任何错误了，所有权被移动出去，所以没有值被释放。
引用的规则
- 在任意给定时间，要么只能有一个可变引用，要么只能有多个不可变引用。
- 引用必须总是有效的。
可变引用
切片，字符串 slice
字符串 slice（string slice）是 String 中一部分值的引用，即 &str 类型
字符串字面值就是 slice
rust
let s = "Hello, world!"; // s是字符串字面量，是 &str 类型这里 s 的类型是 &str ：它是一个指向二进制程序特定位置的 slice 。这也就是为什么字符串字面值是不可变的，&str 是一个不可变引用。
定义一个获取字符串 slice 而不是 String 引用的函数使得我们的 API 更加通用并且不会丢失任何功能：
rust
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[0..i];
}
}
&s[..] //返回整个字符串
}其他类型的 slice
rust
let a = [1, 2, 3, 4, 5];
let slice = &a[1..3];
assert_eq!(slice, &[2, 3]);这个 slice 的类型是 &[i32] 。它跟字符串 slice 的工作方式一样，通过存储第一个集合元素的
引用和一个集合总长度。
5.结构体
元组结构体
元组结构体有着结构体名称提供的含义，但没有具体的字段名，只有字段的类型。
要定义元组结构体，以 struct 关键字和结构体名开头并后跟元组中的类型
rust
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
fn main() {
let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
}注意 black 和 origin 值的类型不同，因为它们是不同的元组结构体的实例。你定义的每一个结构体有其自己的类型，即使结构体中的字段可能有着相同的类型。例如，一个获取 Color 类型参数的函数不能接受 Point 作为参数，即便这两个类型都由三个 i32 值组成。
类单元结构体
类单元结构体常常在你想要在某个类型上实现 trait 但不需要在类型中存储数据的时候发挥作用。
rust
struct AlwaysEqual;
fn main() {
let subject = AlwaysEqual;
}方法语法
方法（method）与函数类似：它们使用 fn 关键字和名称声明，可以拥有参数和返回值，同时包含在某处调用该方法时会执行的代码。不过方法与函数是不同的，因为方法在结构体的上下文中被定义，并且它们第一个参数总是 self ，它代表调用该方法的结构体实例。
rust
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
// impl 块（impl 是 implementation 的缩写）
// 这个 impl 块中的所有内容都将与 Rectangle 类型相关联
// 每个结构体都允许拥有多个 impl 块
impl Rectangle {
// 这里self使用引用，因为我们并不想获取所有权，只希望能够读取结构体中的数据，而不是写入
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()
);
println!("{:#?}", rect1);
}rust的解引用
在 C/C++ 语言中，有两个不同的运算符来调用方法：. 直接在对象上调用方法，而 -> 在一个对象的指针上调用方法，这时需要先解引用（dereference）指针。换句话说，如果 object 是一个指针，那么 object->something() 就像 (*object).something() 一样。
Rust 并没有一个与 -> 等效的运算符；相反，Rust 有一个叫 自动引用 和解引用 （automatic referencing and dereferencing）的功能。方法调用 是 Rust 中少数几个拥有这种行为的地方。
它是这样工作的：当使用 object.something() 调用方法时，Rust 会自动为 object 添加 & 、&mut 或 * 以便使 object 与方法签名匹配。也就是说，这些代码是等价的：
rust
#[derive(Debug,Copy,Clone)]
struct Point {
x: f64,
y: f64,
}
impl Point {
fn distance(&self, other: &Point) -> f64 {
let x_squared = f64::powi(other.x - self.x, 2);
let y_squared = f64::powi(other.y - self.y, 2);
f64::sqrt(x_squared + y_squared)
}
}
fn main() {
let p1 = Point { x: 0.0, y: 0.0 };
let p2 = Point { x: 5.0, y: 6.5 };
p1.distance(&p2);
(&p1).distance(&p2);
}关联函数
所有在 impl 块中定义的函数被称为 关联函数（associated functions），因为它们与 impl 后面命名的类型相关。我们可以定义不以 self 为第一参数的关联函数（因此不是方法 ），因为它们并不作用于一个结构体的实例。我们已经使用了一个这样的函数：在 String 类型上定义的 String::from 函数。
不是方法的关联函数经常被用作返回一个结构体新实例的构造函数。这些函数的名称通常为
new ，但 new 并不是一个关键字。例如我们可以提供一个叫做 square 关联函数，它接受一
个维度参数并且同时作为宽和高，这样可以更轻松的创建一个正方形 Rectangle 而不必指定
两次同样的值：
rust
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn square(size: u32) -> Self {
Self {
width: size,
height: size,
}
}
}
fn main() {
let sq = Rectangle::square(3);
}6.1枚举
枚举（enumerations），也被称作 enums。枚举允许你通过列举可能的 成员（variants）来定义一个类型。
rust
enum IpAddrKind {
V4,
V6,
}
struct IpAddr {
kind: IpAddrKind,
address: String,
}
impl IpAddrKind {
fn call(&self) {
}
}
fn main() {
let home = IpAddr {
kind: IpAddrKind::V4,
address: String::from("127.0.0.1"),
};
let loopback = IpAddr {
kind: IpAddrKind::V6,
address: String::from("::1"),
};
home.kind.call(); // 调用枚举的方法
loopback.kind.call(); // 调用枚举的方法
}
可以使用 impl 来为结构体定义方法那样，在枚举上定义方法
Option 枚举
存于在 Prelude(预导入模块) 中
Rust 并没有空值（NULL），但有一个可以编码存在或不存在概念的枚举，就是 Option
定义如下：
rust
enum Option<T> {
None,
Some(T),
}
rust
fn main() {
let some_number = Some(5); // some_number: Option<i32>
let some_char = Some('e'); // some_char: Option<char>
let absent_number: Option<i32> = None; // None值必须指定 T 的类型
}
rust
fn main() {
let x: i8 = 5;
let y: Option<i8> = Some(5);
let sum = x + y; //（×），因为 Option<T> 和 <T> 不是一个类型，无法直接相加
}6.2模式匹配
match 控制流结构
rust
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,
}
// 上述代码中，每个分支相关联的代码是一个表达式
// 而表达式的结果值将作为整个 match 表达式的返回值
// 类似于代码块
}
fn main() {
let a = Coin::Penny;
let b = Coin::Nickel;
let c = Coin::Dime;
let d = Coin::Quarter;
println!("{} {} {} {}", value_in_cents(a),value_in_cents(b),
value_in_cents(c), value_in_cents(d),);
}与 if 的区别：对于 if ，表达式必须返回一个布尔值，而match参数可以是任何类型
绑定值的模式
匹配分支的另一个有用的功能是可以绑定匹配的模式的部分值。这也就是如何从枚举成员中提取值的。
rust
#[derive(Debug)] // 这样可以立刻看到州的名称
#[warn(non_camel_case_types)]
#[warn(dead_code)]
enum CNState {
Sd,
Hb,
Sx,
Hn
}
enum Coin {
Penny,
Nickel,
Dime,
Quarter(CNState), // Quarter 成员也存放了一个 CNState 值的 Coin 枚举
}
fn value_in_cents(coin: Coin) -> u8 {
match coin {
Coin::Penny => 1,
Coin::Nickel => 5,
Coin::Dime => 10,
Coin::Quarter(state) => { // state会绑定CNState的枚举
println!("{:?}", state);
25
}
}
}
fn main() {
let a = Coin::Penny;
let b = Coin::Nickel;
let c = Coin::Dime;
println!("{} {} {}", value_in_cents(a),value_in_cents(b),
value_in_cents(c));
let d1 = Coin::Quarter(CNState::Sd);
let d2 = Coin::Quarter(CNState::Sx);
let d3 = Coin::Quarter(CNState::Hb);
let d4 = Coin::Quarter(CNState::Hn);
println!("{} {} {} {}", value_in_cents(d1), value_in_cents(d2),
value_in_cents(d3), value_in_cents(d4));
// 如果调用 value_in_cents(d1)
// 当将值与每个分支相比较时，没有分支会匹配，直到遇到Coin::Quarter(state)
// 这时，state 绑定的将会是值 CNState::Sd
// 接着就可以在 println! 表达式中使用这个绑定了
// 像这样就可以获取 Coin 枚举的 Quarter 成员中内部的州的值
}匹配 Option
rust
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
None => None,
Some(i) => Some(i + 1), // 如果传入的x是Some(5)，那么i会绑定5
}
}
fn main() {
let five = Some(5);
let _six = plus_one(five);
let _none = plus_one(None);
}通配模式和 _ 占位符
问题描述：如果你掷出骰子的值为 3，角色不会移动，而是会得到一顶新奇的帽子。如果你掷出了 7，你的角色将失去新奇的帽子。对于其他的数值，你的角会在棋盘上移动相应的格子。
rust
fn main() {
let dice_roll = 9;
match dice_roll {
3 => add_fancy_hat(),
7 => remove_fancy_hat(),
other => move_player(other), // 通配模式
}
fn add_fancy_hat() {}
fn remove_fancy_hat() {}
fn move_player(num_spaces: u8) {}
}让我们改变游戏规则：如果你掷出 3 或 7 以外的值，你的回合将无事发生
rust
fn main() {
let dice_roll = 9;
match dice_roll {
3 => add_fancy_hat(),
7 => remove_fancy_hat(),
_ => (), // 通配模式
}
fn add_fancy_hat() {}
fn remove_fancy_hat() {}
}if let 简洁控制流
只匹配一个模式的值而忽略其他情况
rust
fn main() {
let _v = Some(4);
if let Some(3) = _v {
println!("3！！！");
} else { // 可以配合else
println!("Other");
}
// if let _v = Some(3) { // 错误写法
// println!("3！！！");
// }
}7.1Package, Crate, Module
到目前为止，我们编写的程序都在一个文件的一个模块中。伴随着项目的增长，你应该通过将代码分解为多个模块和多个文件来组织代码。一个包可以包含多个二进制 crate 项和一个可选的 crate 库。伴随着包的增长，你可以将包中的部分代码提取出来，做成独立的 crate，这些 crate 则作为外部依赖项。
模块系统（the modulesystem）：
- 包（Packages）：Cargo 的一个功能，它允许你构建、测试和分享 crate。
- Crates ：一个模块的树形结构，它形成了库或二进制项目。
- 模块（Modules）和 use：允许你控制作用域和路径的私有性。
- 路径（path）：一个命名例如结构体、函数或模块等项的方式
Package 和 Crate
crate 是 Rust 在编译时最小的代码单位。如果你用 rustc 而不是 cargo 来编译一个文件，编译器还是会将那个文件认作一个 crate。crate 可以包含模块，模块可以定义在其他文件，然后和 crate 一起编译
Crate 包含两种类型：
binary（二进制项），二进制项可以被编译为可执行程序，比如一个命令行程序或者一个服务器。它们必须有一个 main 函数来定义当程序被执行的时候所需要做的事情。目前我们所创建的 crate 都是二进制项。library（库），库并没有 main 函数，它们也不会编译为可执行程序，它们提供一些诸如函数之类的东西，使其他项目也能使用这些东西。比如 rand crate 就提供了生成随机数的东西。大多数时间 Rustaceans 说的 crate 指的都是库，这与其他编程语言中 library 概念一致。
Crate root 是一个源文件，Rust 编译器以它为起始点，并构成 crate 的根模块。
包（package）是提供一系列功能的一个或者多个 crate 。一个包会包含一个 Cargo.toml 文
件，阐述如何去构建这些 crate。其中：至多包含一个 library crate，可以包含任意多的 binary crate，但必须至少包含一个 crate。
Cargo 的惯例
src/main.rs
- 作为 binary crate 的 crate root
- crate 名与 package 名相同
如果还存在文件src/lib.rs
- 这意味着 package 包含一个 library crate
- 作为 library crate 的 crate root
- crate 名与 package 名相同
Cargo 把 crate root 文件交给 rustc 来构建 library 或 binary
Crate 的作用
将相关功能组合到一个作用域内，便于在项目间进行共享 ---> 防止冲突
例如 rand crate，访问它的功能需要通过它的名字：rand
定义模块（Module）来控制作用域与私有性
Module：
- 在一个 crate 内，对代码进行分组
- 增加可读性，易于复用
- 控制项目（item）的私有性，public，private
建立 module：
- mod 关键字
- 可嵌套
- 可包含其他项（struct、enum、常量、trait、函数等）的定义
7.2 路径，Path
为了在 rust 的模块中找到某个条目，需要使用路径。
路径的两种形式；
- 绝对路径：从 crate root 开始，使用 crate 名或字面值 crate
- 相对路径：从当前模块开始，使用 self，super 或当前模块的标识符
文件名：src/lib.rs
rust
mod front_of_house {
// hosting模块公有，但是 hosting 的 内容（contents）仍然是私有的
// 这表明使模块公有并不会使其内容也变成公有
// 私有性规则不但应用于模块，还应用于结构体、函数和方法
pub mod hosting {
pub fn add_to_waitlist() {}
}
}
pub fn eat_at_restaurant() {
// 绝对路径，方便定义条目的代码和使用条目的代码彼此独立的移动
crate::front_of_house::hosting::add_to_waitlist();
// 相对路径
front_of_house::hosting::add_to_waitlist();
}私有边界（privacy boundary）
- 模块不仅可以组织代码，还可以定义私有边界
- 如果想把 函数 或 struct 等设为私有，可以把它放到某个模块中
- rust 中的所有条目（函数，方法，struct，enum，模块，常量）默认是私有的。
- 父级模块无法访问子模块中的私有条目
- 子模块可以使用所有祖先模块中的条目
二进制和库 crate 包的最佳实践
我们提到过包可以同时包含一个 src/main.rs 二进制 crate 根和一个 src/lib.rs 库 crate 根，并且这两个 crate 默认以包名来命名。通常，这种包含二进制 crate 和库 crate 的模式的包，在二进制 crate 中只有足够的代码来启动一个可执行文件，可执行文件调用库 crate 的代码。又因为库 crate 可以共享，这使得其它项目从包提供的大部分功能中受益。
模块树应该定义在 src/lib.rs 中。这样通过以包名开头的路径，公有项就可以在二进制 crate 中使用。二进制 crate 就完全变成了同其它外部 crate 一样的库 crate 的用户：它只能使用公有 API。这有助于你设计一个好的 API；你不仅仅是作者，也是用户！
super，从父模块开始构建相对路径
使用 super 允许我们引用父模块中的已知项，这使得重新组织模块树变得更容易 ------ 当模块与父模块关联的很紧密，但某天父模块可能要移动到模块树的其它位置。
创建公有的结构体和枚举
如果我们在一个结构体定义的前面使用了 pub ，这个结构体会变成公有的，但是这个结构体的字段仍然是私有的。我们可以根据情况决定每个字段是否公有。
将枚举类型设为公有后，枚举成员默认是公有的，这与rust的默认私有规则不同。
use
可以使用 use 关键字将路径导入到作用域内，但仍遵循私有性规则
我们将 crate::front_of_house::hosting 模块引入了 eat_at_restaurant 函数的作用域，而我们只需要指定 hosting::add_to_waitlist 即可在 eat_at_restaurant 中调用 add_to_waitlist 函数。
1.函数（指定到父级）：当我们要使用其他模块函数 的时候，一般使用 use 引入这个函数的父级模块
2.struct，enum，其他：指定完整路径（指定到本身）
rust
mod front_of_house {
pub mod hosting {
pub fn add_to_waitlist() {}
}
}
use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
}引入结构体
rust
use std::collections::HashMap; // 指定到HashMap结构体本身
fn main() {
let mut map = HashMap::new(); // 直接使用HashMap即可
map.insert(1, 2);
}将两个具有相同名称但不同父模块的 Result 类型引入作用域
rust
// 使用父模块可以区分这两个 Result 类型。
use std::fmt;
use std::io;
fn function1() -> fmt::Result {
// --snip--
Ok(())
}
fn function2() -> io::Result<()> {
// --snip--
Ok(())
}
// 使用 as 关键字提供新的名称，进而区分两个result
use std::fmt::Result;
use std::io::Result as IoResult;
fn function1() -> Result {
// --snip--
Ok(())
}
fn function2() -> IoResult<()> {
// --snip--
Ok(())
}use 语句只适用于其所在的作用域，下面例子是无法编译的
rust
/*
use 只能创建 use 所在的特定作用域内的短路径。
将 eat_at_restaurant 函数移动到了一个叫 customer 的子模块
这又是一个不同于 use 语句的作用域，所以函数体不能编译。
*/
mod front_of_house {
pub mod hosting {
pub fn add_to_waitlist() {}
}
}
use crate::front_of_house::hosting;
mod customer {
pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
}
}使用 pub use 重导出名称
使用 use 关键字，将某个名称导入当前作用域后，这个名称在此作用域中就可以使用了，但它对此作用域之外还是私有 的。如果想让其他人调用我们的代码时，也能够正常使用这个名称，就好像它本来就在当前作用域一样，那我们可以将 pub 和 use 合起来使用。这种技术被称为 "重导出（re-exporting）"：我们不仅将一个名称导入了当前作用域，还允许别人把它导入他们自己的作用域。
rust
mod front_of_house {
pub mod hosting {
pub fn add_to_waitlist() {}
}
}
pub use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
hosting::add_to_waitlist();
}使用外部包
在 Cargo.toml 中加入 rand 依赖告诉了 Cargo 要从 crates.io 下载 rand 和其依赖，并使其可
在项目代码中使用。
rust
rand = "0.8.5"为了将 rand 定义引入项目包的作用域，我们加入一行 use 起始的包名，它以 rand 包名开头，并列出了需要引入作用域的项。
rust
use rand::Rng;
fn main() {
let secret_number = rand::thread_rng().gen_range(1..=100);
}注意 std 标准库对于你的包来说也是外部 crate。
rust
use std::collections::HashMap;这是一个以标准库 crate 名 std 开头的绝对路径。
嵌套路径来消除大量的 use 行
如果使用同一个包或模块下的多个条目，可以使用嵌套路径在同一行内将上述条目进行引入：
路径相同的部分 :: 路径差异的部分
rust
use std::{cmp::Ordering, io};
rust
// use std::io;
// use std::io::Write;
use std::io::{self, Write};
rust
// 谨慎使用，一般用于测试，有时被用于预导入模块
use std::collections::*;将模块拆分成多个文件
模块定义时，如果模块名后边是 `;`` ，而不是代码块，那么：
- Rust 会从与模块同名的文件中加载内容（同级文件夹中）
- 模块树的结构不会变化
路径的层级结构要和模块的层级结构相匹配