好的，这是一篇关于 Rust 指令和代码片段的综合性文章，旨在为您提供一个实用的“备忘录”和入门指南。

---

Rust 指令代码大全：从入门到精通的实用指南

Rust 语言以其卓越的性能、内存安全性和并发处理能力而闻名，但它的学习曲线也颇为陡峭。无论是系统编程、Web 后端还是嵌入式开发，掌握其核心指令和代码模式都至关重要。本文将成为您的 Rust 代码大全，涵盖从基础到进阶的常用代码片段和指令。

一、基础入门：Hello World 与项目管理

任何语言的学习都从“Hello, World!”开始。

1. 创建新项目 (Cargo指令)
Cargo 是 Rust 的包管理器和构建工具，绝大多数指令都通过它完成。

```bash
# 创建一个新的二进制（可执行）项目
cargo new my_project

# 创建一个新的库项目
cargo new my_lib --lib

# 编译并运行项目（在项目根目录下）
cargo run

# 仅编译检查，不生成可执行文件，速度更快
cargo check

# 编译并生成优化后的 release 版本
cargo build --release
```

2. 经典的 main.rs
项目创建后，在 `src/main.rs` 中你会看到：

```rust
fn main() {
println!("Hello, world!");
}
```
- `fn main()`: 定义主函数，是程序的入口点。
- `println!()`: 这是一个宏（以 `!` 结尾），用于向标准输出打印一行文本。

二、核心概念代码片段

1. 变量与可变性
Rust 变量默认是不可变的，这是其安全性的基石之一。

```rust
let x = 5; // 不可变变量
// x = 6; // 错误：不能对不可变变量二次赋值

let mut y = 5; // 使用 `mut` 关键字声明可变变量
y = 10; // 正确

const MAX_POINTS: u32 = 100_000; // 常量，必须标注类型
```

2. 数据类型
Rust 是静态类型语言，编译时必须知道所有变量的类型。

```rust
// 标量类型
let integer: i32 = -42; // 有符号整数
let unsigned: u64 = 42; // 无符号整数
let floating: f64 = 3.14; // 浮点数
let boolean: bool = true; // 布尔值
let character: char = 'z'; // 字符

// 复合类型：元组 (Tuple)
let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup; // 解构
let first = tup.0; // 通过索引访问

// 复合类型：数组 (Array) - 固定长度
let arr = [1, 2, 3, 4, 5];
let first_arr = arr[0];
```

3. 控制流
```rust
// if 表达式（注意：不是语句，它可以返回值）
let number = if condition { 5 } else { 6 };

// 循环: loop, while, for
loop { // 无限循环，可用 `break` 退出
println!("again!");
break;
}

while condition {
// 条件循环
}

// for 循环是最常用的，用于遍历集合
for element in arr.iter() {
println!("the value is: {}", element);
}
for number in 1..4 { // 范围，输出 1, 2, 3
println!("{}", number);
}
```

三、核心特性：所有权、借用与生命周期

这是 Rust 最独特的部分，确保了内存安全。

1. 所有权与移动 (Move)
```rust
let s1 = String::from("hello");
let s2 = s1; // s1 的所有权被移动到 s2
// println!("{}", s1); // 错误！s1 不再有效
```

2. 借用 (Borrowing) - 引用
为了避免移动所有权，我们可以使用引用 (`&`)。

```rust
let s1 = String::from("hello");
let len = calculate_length(&s1); // 传递一个不可变引用
println!("The length of '{}' is {}.", s1, len); // s1 仍然有效

fn calculate_length(s: &String) -> usize { // s 是对 String 的引用
s.len()
} // 这里 s 离开作用域，但因为它没有所有权，所以什么也不会发生

// 可变引用
let mut s = String::from("hello");
change(&mut s); // 传递一个可变引用

fn change(some_string: &mut String) {
some_string.push_str(", world");
}
// 重要规则：在特定作用域中的特定数据只能有一个可变引用，且不能与不可变引用同时存在。
```

四、常用集合类型

1. Vector (`Vec`)
动态大小的数组。

```rust
let mut v: Vec = Vec::new();
v.push(1);
v.push(2);

let v2 = vec![1, 2, 3]; // 使用宏方便地创建
let third: &i32 = &v2[2]; // 索引访问，可能 panic
match v.get(2) { // 安全访问，返回 Option<&T>
Some(third) => println!("The third element is {}", third),
None => println!("There is no third element."),
}
```

2. 字符串 (`String`)
Rust 的字符串是 UTF-8 编码的，有些复杂。

```rust
let mut s = String::from("foo");
s.push_str("bar");
let s2 = s + " baz"; // 注意：这里 s 的所有权会被移动

// 拼接多个字符串推荐使用 format! 宏
let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");
let s = format!("{}-{}-{}", s1, s2, s3); // 不会获取任何参数的所有权
```

3. 哈希映射 (`HashMap`)
```rust
use std::collections::HashMap;

let mut scores = HashMap::new();
scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

let team_name = String::from("Blue");
let score = scores.get(&team_name); // 返回 Option<&V>
```

五、错误处理

Rust 没有异常，而是使用 `Result` 类型来处理可恢复错误。

```rust
use std::fs::File;
use std::io::ErrorKind;

// 使用 match 进行详细的错误处理
let f = File::open("hello.txt");
let f = match f {
Ok(file) => file,
Err(error) => match error.kind() {
ErrorKind::NotFound => match File::create("hello.txt") {
Ok(fc) => fc,
Err(e) => panic!("Problem creating the file: {:?}", e),
},
other_error => {
panic!("Problem opening the file: {:?}", other_error)
}
},
};

// 使用 unwrap 或 expect 简化（如果出错则直接 panic）
let f = File::open("hello.txt").unwrap();
let f = File::open("hello.txt").expect("Failed to open hello.txt");

// 传播错误：更优雅的方式是使用 `?` 操作符将错误返回给调用者
fn read_username_from_file() -> Result {
let mut s = String::new();
File::open("hello.txt")?.read_to_string(&mut s)?;
Ok(s)
}
// `?` 运算符在遇到 Err 时会提前返回错误，如果是 Ok 则解包出值。
```

---

总结

这份“代码大全”涵盖了 Rust 开发中最常用和最关键的概念与指令。要真正掌握 Rust，光看是不够的：

1. 多写代码：在 [Rust Playground](https://play.rust-lang.org/) 上尝试这些片段。
2. 阅读文档：`cargo doc --open` 命令可以在本地生成并打开所有依赖的文档。
3. 遵循编译器提示：Rust 编译器以其出色的错误信息和修复建议而闻名，仔细阅读它是学习的最佳途径。

希望这篇文章能成为您 Rust 之旅中一份有价值的快速参考指南！