rust基础

StoneLiu999

已于 2023-08-30 11:43:57 修改

阅读量1.6k

点赞数

分类专栏：前端文章标签： rust 开发语言后端

于 2023-08-24 10:43:58 首次发布

本文链接：https://blog.csdn.net/momo0853/article/details/132469143

版权

前端专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

关键字
基本类型和数据结构
内置宏
std模块

rust的主要文档就是官方文档 The Rust Programming Language，还有中文的 Rust语言圣经(Rust Course)。学习之后从在这里找一些优秀的开源项目学习一下 awesome-rust。开发的时候可以从 Rust Package Registry找找有那些适合自己使用的库避免重复造轮子。

关键字

Rust 中的关键字是一些具有特殊用途的保留字，它们在编程语言中有着特定的含义和功能。下面是 Rust 所有的关键字及其详细解释：

as：类型转换关键字。可以将一个值转换为另外一个类型。
async：声明异步函数的关键字。异步函数可以暂停执行，等待某些操作完成后再继续执行。
await：等待异步操作完成的关键字。用于在异步函数中暂停执行，等待异步操作的结果。
break：跳出循环的关键字。用于提前终止循环并跳出循环体。
const：声明常量的关键字。常量是一个不可变的值，在编译时就已经确定了。
continue：跳过本次循环的剩余部分，进行下一次循环的关键字。
crate：表示当前代码所在的 crate（代码库）的关键字。
dyn：指明动态分发类型的关键字。用于定义和使用 trait 对象。
else：if 条件不满足时执行的分支的关键字。
enum：声明枚举类型的关键字。枚举类型允许定义一个值只能为几个预定义选项之一的类型。
extern：与外部代码（通常是其他语言编写的）进行交互的关键字。
false：布尔型字面量，表示 false。
fn：声明函数的关键字。用于定义一个函数及其参数、返回类型和函数体。
for：用于迭代集合或范围的关键字。
if：条件语句的关键字。用于根据条件执行不同的代码分支。
impl：实现接口（trait）或类型的关键字。用于为类型提供方法实现或为接口定义默认实现。
in：在 for 循环中指定集合元素的关键字。
let：声明变量的关键字。用于创建一个新的变量并将其绑定到一个值。
loop：无限循环的关键字。用于反复执行一段代码，直到遇到 break 关键字。
match：模式匹配语句的关键字。用于根据一个或多个模式选择相应的执行分支。
mod：声明模块的关键字。用于组织代码并将相关的项（函数、结构体等）放在同一个作用域中。
move：将闭包获取所有权的关键字。用于强制闭包获取其使用的变量的所有权。
mut：声明可变绑定的关键字。用于创建一个可变的变量绑定。
pub：声明公共项（函数、结构体等）的关键字。用于指定一个项对外部可见。
ref：声明引用的关键字。用于创建一个引用，允许在不转移所有权的情况下访问数据。
return：从函数中返回值的关键字。
Self：表示实现 trait 的类型自身的关键字。
self：表示当前实例的关键字。在方法定义中使用，表示实例本身。
static：声明静态变量的关键字。静态变量在程序的整个生命周期内保持不变。
struct：声明结构体类型的关键字。结构体是一种用户自定义的数据类型，用于组合多个值。
super：表示父模块的关键字。
trait：声明 trait 的关键字。trait 定义了一组行为，可由多个类型实现。
true：布尔型字面量，表示 true。
type：声明类型别名的关键字。可以为某个类型定义一个别名。
unsafe：标记代码块为不安全的关键字。允许执行一些 unsafe 操作，如访问原始指针和执行未定义行为。
use：导入模块或项的关键字。用于在代码中使用其他模块中定义的函数、结构体等。
where：在泛型约束中指定额外的条件的关键字。
while：循环语句的关键字。用于反复执行一段代码，直到给定条件不再满足。

这些关键字在 Rust 中有着特殊的含义和功能，你可以在编写代码时使用它们来实现特定的行为或语法结构。

基本类型和数据结构

Rust 提供了一些基本的数据结构，以下是其中几种常用的：

基本数据类型：
- bool：布尔类型，值为 true 或 false。
- char：字符类型，表示一个 Unicode 字符。
- u8、u16、u32、u64、u128：无符号整数类型，分别表示8位、16位、32位、64位和128位的无符号整数。
- i8、i16、i32、i64、i128：有符号整数类型，分别表示8位、16位、32位、64位和128位的有符号整数。
- f32、f64：浮点数类型，分别表示32位和64位的浮点数。

数组（Array）：具有固定长度、元素类型相同的数据结构。

let arr: [i32; 5] = [1, 2, 3, 4, 5]; // 定义包含5个i32元素的数组

元组（Tuple）：具有固定长度、元素类型可以不同的数据结构。

let tup: (i32, f64, bool) = (42, 3.14, true); // 元组包含一个i32、一个f64和一个bool值

切片（Slice）：对数组或其他集合的可变长度视图。

let arr: [i32; 5] = [1, 2, 3, 4, 5];
let slice: &[i32] = &arr[1..3]; // 切片包含数组的一部分 [2, 3]

字符串（String）：动态可增长的文本数据类型。

let s: String = String::from("Hello, Rust!"); // 创建一个字符串

向量（Vector）：一个动态可变长度的数组。

let mut vec: Vec<i32> = Vec::new(); // 创建一个空的向量
vec.push(1); // 向向量中插入元素

结构体（Struct）：自定义的复合数据类型，可以包含不同类型的字段。

struct Person {
    name: String,
    age: u32,
}
let person = Person { name: String::from("Alice"), age: 30 };

枚举（Enum）：一种用于定义类型的数据结构，它可以表示多个可能的取值。

enum Color {
    Red,
    Green,
    Blue,
}
let color = Color::Red; // 枚举变量可以有不同的取值

Option：用于表示一个可能为空的值的枚举类型。

let some_value: Option<i32> = Some(42); // 存在值的情况
let no_value: Option<i32> = None; // 不存在值的情况

Result：用于表示一个操作的结果，可能是成功或错误的枚举类型。

use std::fs::File;
let file_result: Result<File, std::io::Error> = File::open("file.txt"); // 操作的结果

// 通过模式匹配处理 Result 的不同情况
match file_result {
    Ok(file) => println!("文件打开成功！"),
    Err(error) => println!("文件打开失败: {:?}", error),
}

Range：表示一个范围的数据结构。

let range1 = 1..5; // 从 1 到 4 的半开区间 [1, 5)
let range2 = 1..=5; // 从 1 到 5 的闭区间 [1, 5]

Iterator：用于迭代集合元素的 trait。

let numbers = vec![1, 2, 3, 4, 5];
for num in numbers.iter() {
    println!("Number: {}", num);
}

Closure：一个可以捕获外部变量的匿名函数。

let add = |a: i32, b: i32| a + b; // 定义一个加法闭包
let sum = add(3, 5); // 调用闭包

Box：用于在堆上分配内存的智能指针。

let boxed_value: Box<i32> = Box::new(42); // 在堆上分配一个整数

Reference（引用）：用于借用其他值而不获取其所有权的数据类型。
```
let value = 42;
let reference: &i32 = &value; // 借用 value 的引用
```

Slice（切片）：对数组、字符串或其他集合的不可变引用。

let arr: [i32; 5] = [1, 2, 3, 4, 5];
let slice: &[i32] = &arr[1..3]; // 对数组的切片

Cow（Copy-on-write）：在需要时才复制数据的智能指针。

use std::borrow::Cow;
fn process(data: Cow<str>) {
    // 处理数据
}
let s: String = String::from("hello");
process(Cow::Borrowed(&s)); // 传递一个借用的字符串

HashMap：用于存储键值对的哈希映射表。

use std::collections::HashMap;

let mut map = HashMap::new();
map.insert("name", "Alice");
map.insert("age", "25");

if let Some(name) = map.get("name") {
    println!("Name: {}", name);
}

HashSet：用于存储唯一值的哈希集合。

use std::collections::HashSet;

let mut set = HashSet::new();
set.insert(1);
set.insert(2);
set.insert(3);

for num in set.iter() {
    println!("Number: {}", num);
}

BTreeMap：一个基于平衡二叉树的有序键值对集合。

use std::collections::BTreeMap;

let mut map = BTreeMap::new();
map.insert(3, "C");
map.insert(1, "A");
map.insert(2, "B");

for (key, value) in map.iter() {
    println!("Key: {}, Value: {}", key, value);
}

BTreeSet：一个基于平衡二叉树的有序集合。

use std::collections::BTreeSet;

let mut set = BTreeSet::new();
set.insert(3);
set.insert(1);
set.insert(2);

for num in set.iter() {
    println!("Number: {}", num);
}

VecDeque：双端队列，支持在两端进行插入和删除操作。

use std::collections::VecDeque;

let mut deque = VecDeque::new();
deque.push_back(1);
deque.push_front(2);
deque.push_back(3);

while let Some(num) = deque.pop_front() {
    println!("Number: {}", num);
}

LinkedList：双向链表。

use std::collections::LinkedList;

let mut list = LinkedList::new();
list.push_back(1);
list.push_front(2);
list.push_back(3);

for num in list.iter() {
    println!("Number: {}", num);
}

BinaryHeap：二叉堆，可以高效地找到最大（或最小）的元素。

use std::collections::BinaryHeap;

let mut heap = BinaryHeap::new();
heap.push(3);
heap.push(1);
heap.push(2);

while let Some(num) = heap.pop() {
    println!("Number: {}", num);
}

这些是更多常见的基本数据结构，它们可以在 Rust 中用于不同的场景和问题。根据具体的需求，选择合适的数据结构可以提高程序的效率和可读性。

内置宏

Rust 的宏（macros）是一种元编程（metaprogramming）功能，允许在编译时根据代码生成和转换代码。宏提供了一种方便且灵活的方式来自动化代码的生成和重复工作的处理。Rust 中的宏有两种类型：声明式宏（Declarative Macros）和过程宏（Procedural Macros）。

声明式宏（Declarative Macros）：
- 声明式宏使用 macro_rules! 关键字定义。它们是基于模式匹配的简单文本替换规则。
- 声明式宏通常用于代码重复的抽象和简化。您可以定义自己的自定义宏，或使用标准库中提供的宏，如 println! 和 vec!。
- 声明式宏将输入的代码与模式进行匹配，并根据提供的规则进行替换。
- 例如，vec![1, 2, 3] 宏将被扩展为 Vec::from(vec![1, 2, 3])。
过程宏（Procedural Macros）：
- 过程宏是基于函数式的宏，允许更复杂的代码转换和生成。
- 过程宏可以分为三个不同类型：属性宏（Attribute Macros）、函数宏（Function Macros）和派生宏（Derive Macros）。
- 属性宏允许您在项上附加自定义属性并进行代码处理。
- 函数宏接受代码片段作为输入，并产生转换后的代码片段。
- 派生宏用于自动实现某些 trait，例如 serde 库中的 #[derive(Serialize, Deserialize)]。

宏的使用有助于减少重复代码，提高代码的可读性和可维护性。宏可以将通用模式抽象为代码模板，从而简化开发过程。然而，需要注意的是，滥用宏可能导致代码难以理解和调试，因此需要谨慎使用。

要了解更多关于 Rust 宏的详细信息和示例，请参阅官方文档：Rust Macros。

内置函数宏

以下是 Rust 中一些常用的系统内置宏：

println! 和 eprintln!：用于打印消息到标准输出和标准错误输出。
format! 和 formatln!：用于格式化字符串，将格式化后的结果作为一个 String 对象返回。
assert!、assert_eq! 和 debug_assert!：用于进行断言检查，如果条件不满足，则触发 panic。
file!、line! 和 column!：分别返回当前代码所在的文件名、行号和列号。
concat! 和 concat_idents!：用于将多个字符串或标识符连接成一个新的字符串或标识符。
env! 和 option_env!：用于获取环境变量的值。
cfg!：用于进行编译时条件判断，根据不同的条件编译不同的代码。
include!、include_str! 和 include_bytes!：用于将外部文件的内容包含到当前代码中。
vec!、vecdeque!、hashmap! 和 hashset!：用于创建容器类型的宏，如 Vec、VecDeque、HashMap 和 HashSet。
format_args!：用于创建一个格式化参数对象，可以被传递给其他格式化宏。

这些是 Rust 中一些常见的系统内置宏，通过它们可以进行打印、断言、字符串拼接、编译时条件判断等常见操作。它们提供了方便而强大的功能，可以帮助简化代码编写和调试过程。完整的宏列表可以在 Rust 官方文档中找到。

例子

println! 和 eprintln!：这些宏用于将消息打印到标准输出和标准错误输出。示例：

fn main() {
    let name = "Alice";
    let age = 25;
    println!("Hello, {}! You are {} years old.", name, age);
    eprintln!("This is an error message.");
}

输出：

Hello, Alice! You are 25 years old.
This is an error message.

format! 和 formatln!：这些宏用于格式化字符串，并返回一个包含格式化结果的 String 对象。示例：

fn main() {
    let name = "Bob";
    let age = 30;
    let message = format!("Hello, {}! You are {} years old.", name, age);
    println!("{}", message);
}

输出：

Hello, Bob! You are 30 years old.

assert!、assert_eq! 和 debug_assert!：这些宏用于进行断言检查。如果条件不满足，则会触发 panic。示例：
```
fn divide(a: i32, b: i32) -> i32 {
    assert!(b != 0, "Divisor cannot be zero.");
    a / b
}

fn main() {
    let result = divide(10, 2);
    assert_eq!(result, 5);
}
```
如果将 divide(10, 0) 调用，它会触发断言错误并打印出相应的错误信息。

file!、line! 和 column!：这些宏用于获取当前代码所在的文件名、行号和列号。示例：

fn main() {
    println!("This statement is in file: {}, line: {}, column: {}",
            file!(), line!(), column!());
}

输出：

This statement is in file: main.rs, line: 3, column: 25

concat! 和 concat_idents!：这些宏用于将多个字符串或标识符连接成一个新的字符串或标识符。示例：

macro_rules! create_struct {
    ($name:ident, $($field:ident),*) => {
        struct $name {
            $( $field: i32 ),*
        }
    };
}

create_struct!(MyStruct, x, y, z);

fn main() {
    let my_struct = MyStruct {
        x: 1,
        y: 2,
        z: 3,
    };
    println!("{:?}", my_struct);
}

宏 create_struct! 用于生成一个具有给定字段的结构体类型。在这个例子中，我们创建了一个 MyStruct 结构体类型，并创建了一个相应的实例。

env! 和 option_env!：这些宏用于获取环境变量的值。示例：

fn main() {
    let home_dir = env!("HOME");
    println!("Home directory: {:?}", home_dir);
    
    let rustc_version = option_env!("RUSTC_VERSION");
    println!("Rustc version: {:?}", rustc_version);
}

输出：

Home directory: "/Users/username"
Rustc version: Some("1.55.0")

env! 用于获取指定环境变量的值，而 option_env! 则返回一个 Option<&str> 类型，表示可能存在或不存在的环境变量值。

cfg!：这个宏用于在编译时根据条件来选择性地包含或排除代码块。示例：

fn main() {
    #[cfg(feature = "debug_mode")]
    {
        println!("Running in debug mode.");
        // 这个代码块只会在 `debug_mode` 特性被启用时编译和执行
    }

    #[cfg(not(feature = "debug_mode"))]
    {
        println!("Running in release mode.");
        // 这个代码块只会在 `debug_mode` 特性未被启用时编译和执行
    }
}

通过在 Cargo.toml 文件中设置相应的 feature，可以选择是否启用某个特定的功能。

include!：这个宏用于将外部文件的内容嵌入到当前源文件中。示例：
```
fn main() {
    include!("config.rs");
    // 将 config.rs 文件的内容嵌入到此处
}
```
这对于包含配置文件或其他代码片段非常有用。
include_str!：这个宏用于将外部文件的内容作为字符串字面量嵌入到当前源文件中。示例：
```
fn main() {
    let license = include_str!("license.txt");
    println!("License:\n{}", license);
}
```
这对于包含文本文件的内容非常有用。
include_bytes!：这个宏用于将外部文件的内容作为字节切片嵌入到当前源文件中。示例：
```
fn main() {
    let image_data = include_bytes!("image.png");
    // 处理 image.png 文件的字节数据
}
```
这对于包含二进制文件的内容非常有用。

vec!：这个宏用于创建包含多个元素的 Vec 对象。示例：

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    println!("{:?}", numbers);
}

输出：

[1, 2, 3, 4, 5]

vecdeque!：这个宏用于创建包含多个元素的 VecDeque（双端队列）对象。示例：

use std::collections::VecDeque;

fn main() {
    let queue = vecdeque![1, 2, 3, 4, 5];
    println!("{:?}", queue);
}

输出：

[1, 2, 3, 4, 5]

hashmap! 和 hashset!：这些宏用于创建 HashMap 和 HashSet 对象，并可以用初始键值对或元素列表进行初始化。示例：

use std::collections::{HashMap, HashSet};

fn main() {
    let map = hashmap!{
        "key1" => "value1",
        "key2" => "value2",
    };
    println!("{:?}", map);

    let set = hashset![1, 2, 3, 4, 5];
    println!("{:?}", set);
}

输出：

{"key1": "value1", "key2": "value2"}
[1, 2, 3, 4, 5]

format_args!：这个宏用于构造格式化参数，可以与 std::fmt 相关的函数一起使用。示例：

fn main() {
    let name = "Alice";
    let age = 25;
    let message = format_args!("Hello, {}! You are {} years old.", name, age);
    println!("{}", message);
}

输出：

Hello, Alice! You are 25 years old.

内置派生宏

Rust 提供了一些内置的派生宏，可以通过 #[derive] 注解来使用它们。以下是 Rust 中常用的内置派生宏：

Debug：用于为结构体或枚举实现 std::fmt::Debug trait，以便可以使用 {:?} 格式化输出调试信息。
```
#[derive(Debug)]
struct MyStruct {
    // 结构体字段
}
```
Clone：用于为结构体或枚举实现 std::clone::Clone trait，以便可以进行深拷贝。
Copy：用于为结构体或枚举实现 std::marker::Copy trait，以便可以进行浅拷贝。
PartialEq 和 Eq：用于为结构体或枚举实现相等性比较的 traits，即 std::cmp::PartialEq 和 std::cmp::Eq。
PartialOrd 和 Ord：用于为结构体或枚举实现排序的 traits，即 std::cmp::PartialOrd 和 std::cmp::Ord。
Default：用于为结构体或枚举实现 std::default::Default trait，以便可以创建默认值。
Hash：用于为结构体或枚举实现 std::hash::Hash trait，以便可以进行哈希操作。
Iterator：用于为结构体或枚举实现迭代器相关的 traits，例如 std::iter::Iterator、std::iter::ExactSizeIterator 等。
Serialize 和 Deserialize：用于为结构体或枚举实现序列化和反序列化的 traits，即 serde::Serialize 和 serde::Deserialize。
From 和 Into：用于为结构体或枚举实现类型转换的 traits，即 std::convert::From 和 std::convert::Into。
Deref 和 DerefMut：用于为结构体或枚举实现解引用的 traits，即 std::ops::Deref 和 std::ops::DerefMut。
Send 和 Sync：用于为结构体或枚举标记为可跨线程发送和共享的 traits。

这些是 Rust 中一些常用的内置派生宏示例。通过使用这些派生宏，我们可以轻松地为结构体或枚举实现一些常见的 traits，从而减少手动编写的代码量。

内置属性宏

在 Rust 中，属性宏是一种用于自定义标记和操作 Rust 代码的机制。而内置属性宏是 Rust 的一些预定义的属性宏，它们具有特定的功能和语义。以下是一些常见的内置属性宏：

cfg：cfg 属性宏可以根据条件编译来选择性地包含或排除代码。它接受一个布尔表达式作为参数。
```
#[cfg(target_os = "linux")]
fn linux_specific_function() {
    // 仅在 Linux 上运行的代码
}
```
derive：derive 属性宏用于从 Rust 源代码中自动派生实现某些 traits（如前面所提到的 Debug、Clone 等）。
```
#[derive(Debug, Clone)]
struct MyStruct {
    // 结构体字段
}
```
repr：repr 属性宏用于指定类型的内部表示形式。它通常与 #[repr(C)] 或 #[repr(transparent)] 一起使用。
```
#[repr(C)]
struct MyStruct {
    // 结构体字段
}
```

allow 和 deny：allow 和 deny 属性宏用于控制编译器警告的行为。可以使用具体的警告名称来启用或禁用特定类型的警告。

#[allow(dead_code)]
fn unused_function() {
    // 未使用的函数
}

#[deny(unused_variables)]
fn unused_variable() {
    let x = 42; // 产生未使用变量的警告
}

test：test 属性宏用于标记测试单元，以便在运行测试时执行相关代码。

#[cfg(test)]
mod tests {
    #[test]
    fn test_example() {
        // 测试代码
    }
}

这些是 Rust 中一些常见的内置属性宏示例。通过使用内置属性宏，我们可以在编译时控制代码的行为、自动派生实现 traits、控制警告和执行测试等。

过程宏

Rust 中的过程宏（Procedural Macros）允许开发者自定义编译器扩展，通过宏来生成、转换和分析 Rust 代码。过程宏有三种不同的类型：自定义派生（Custom Derive）、属性宏（Attribute Macro）和函数宏（Function-like Macro）。

自定义派生（Custom Derive）宏：
自定义派生宏允许用户为自定义的数据结构自动生成特定的 trait 实现。使用 #[derive] 注解来应用自定义派生宏。下面是一个示例：
```
// 定义自定义派生宏
use proc_macro;

#[proc_macro_derive(DebugPrint)]
pub fn debug_print_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    // 这里可以编写代码来根据输入生成相应的代码
    // 以实现 DebugPrint trait 的功能
}

// 使用自定义派生宏
#[derive(DebugPrint)]
struct MyStruct {
    // 结构体的字段
}
```
在上述示例中，debug_print_derive 函数是一个自定义的派生宏。当我们在结构体上加上 #[derive(DebugPrint)] 注解时，编译器会调用 debug_print_derive 函数来生成相应的 trait 实现代码。

属性宏（Attribute Macro）：
属性宏可以用于修改或添加注解到代码中的项（item），例如结构体、函数或方法等。下面是一个示例：

// 定义属性宏
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_attribute]
pub fn route(args: TokenStream, input: TokenStream) -> TokenStream {
    // 解析输入
    let input = parse_macro_input!(input as DeriveInput);

    // 根据需要修改或添加注解

    // 生成修改后的 TokenStream
    let result = quote! {
        // 修改后的代码
    };

    // 返回修改后的 TokenStream
    result.into()
}

// 使用属性宏
#[route(GET, "/")]
fn index() {
    // 函数体
}

在上述示例中，route 函数是一个属性宏。当我们在函数上加上 #[route(GET, "/")] 注解时，编译器会调用 route 函数来修改或添加相应的注解和代码。

函数宏（Function-like Macro）：
函数宏接受一些输入，并生成相应的输出。函数宏可以像函数调用一样使用，并以 ! 结尾。下面是一个示例：

// 定义函数宏
use proc_macro::TokenStream;
use syn::{parse_macro_input, LitStr};

#[proc_macro]
pub fn hello(input: TokenStream) -> TokenStream {
    // 解析输入
    let input = parse_macro_input!(input as LitStr);

    // 从输入中获取字符串内容
    let name = input.value();

    // 生成输出
    let output = format!("Hello, {}!", name);

    // 将输出转换为 TokenStream
    output.parse().unwrap()
}

// 使用函数宏
fn main() {
    let name = "Alice";
    let message = hello!("{}" , name);
    println!("{}", message);
}

在上述示例中，hello 函数是一个函数宏。当我们使用 hello! 宏来调用时，它会接受一个字符串作为输入，并根据输入生成相应的输出。

这些是 Rust 中过程宏的不同类型和示例。使用过程宏可以根据需要定制和扩展 Rust 语言的功能，使得代码编写更加灵活和高效。

std模块

std::collections（集合模块）：

use std::collections::{HashMap, HashSet};

fn main() {
    let mut map = HashMap::new();
    map.insert(1, "One");
    map.insert(2, "Two");

    let set: HashSet<i32> = vec![1, 2, 3].into_iter().collect();

    println!("{:?}", map);
    println!("{:?}", set);
}

std::io（输入输出模块）：

use std::io::{self, Read};

fn main() -> io::Result<()> {
    let mut buffer = String::new();

    io::stdin().read_to_string(&mut buffer)?;

    println!("You entered: {}", buffer);

    Ok(())
}

std::fs（文件系统模块）：

use std::fs;

fn main() -> std::io::Result<()> {
    let content = "Hello, Rust!";
    fs::write("file.txt", content)?;

    let read_content = fs::read_to_string("file.txt")?;
    println!("{}", read_content);

    Ok(())
}

std::thread（线程模块）：

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 1..=5 {
            println!("Thread A: {}", i);
            thread::sleep(Duration::from_millis(500));
        }
    });

    for i in 1..=5 {
        println!("Thread Main: {}", i);
        thread::sleep(Duration::from_millis(500));
    }
}

std::sync（同步模块）：

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));

    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });

        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {:?}", *counter.lock().unwrap());
}

std::time（时间模块）：

use std::time::{Duration, Instant};

fn main() {
    let start = Instant::now();

    // 执行某些操作...

    let duration = start.elapsed();
    println!("Time elapsed: {:?}", duration);
}

std::path（路径模块）：

use std::path::Path;

fn main() {
    let path = Path::new("/home/user/file.txt");
    println!("Filename: {}", path.file_name().unwrap().to_str().unwrap());
    println!("Parent: {:?}", path.parent());
    println!("Extension: {:?}", path.extension());
}

std::net（网络模块）：

use std::io::{self, Read, Write};
use std::net::{TcpListener, TcpStream};

fn main() -> io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080")?;

    for stream in listener.incoming() {
        let mut stream = stream?;
        let mut buffer = [0; 1024];
        stream.read(&mut buffer)?;
        stream.write_all(b"HTTP/1.1 200 OK\r\n\r\nHello, Rust!")?;
        stream.flush()?;
    }

    Ok(())
}

std::env（环境变量模块）：

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();

    println!("Program name: {}", args[0]);

    if let Some(arg) = args.get(1) {
        println!("First argument: {}", arg);
    }

    let current_dir = env::current_dir().unwrap();
    println!("Current directory: {:?}", current_dir);
}

std::fmt（格式化模块）：

fn main() {
    let name = "Alice";
    let age = 30;

    println!("Name: {}, Age: {}", name, age);
    println!("Binary: {:b}, Hex: {:x}", 10, 20);
    println!("Debug: {:?}", (name, age));
}

std::error（错误处理模块）：

use std::fs;

fn read_file() -> Result<String, std::io::Error> {
    fs::read_to_string("file.txt")
}

fn main() {
    match read_file() {
        Ok(content) => println!("File content: {}", content),
        Err(error) => eprintln!("Error reading file: {}", error),
    }
}

std::convert（类型转换模块）：

fn main() {
    let number: i32 = 42;
    let float_number: f64 = number as f64;
    let string_number: String = number.to_string();

    println!("Float number: {}", float_number);
    println!("String number: {}", string_number);
}

std::process（进程模块）：

use std::process::Command;

fn main() {
    let output = Command::new("ls").arg("-l").output().unwrap();

    if output.status.success() {
        let result = String::from_utf8_lossy(&output.stdout);
        println!("Command output: {}", result);
    } else {
        let error = String::from_utf8_lossy(&output.stderr);
        eprintln!("Command failed: {}", error);
    }
}

std::str（字符串模块）：

fn main() {
    let s = "Hello, Rust!";
    println!("Length: {}", s.len());

    let reversed: String = s.chars().rev().collect();
    println!("Reversed: {}", reversed);

    let parts: Vec<&str> = s.split(", ").collect();
    println!("{:?}", parts);
}

std::cmp（比较模块）：

fn main() {
    let a = 10;
    let b = 20;

    println!("Max: {}", a.max(b));
    println!("Min: {}", a.min(b));
    println!("10 > 20: {}", a > b);
}

std::hash（哈希模块）：

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};

fn main() {
    let mut hasher = DefaultHasher::new();
    "Hello, Rust!".hash(&mut hasher);
    let hash_value = hasher.finish();
    println!("Hash value: {}", hash_value);
}

std::ops（操作符模块）：

use std::ops::Add;

#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

impl Add<Point> for Point {
    type Output = Point;

    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 3, y: 4 };
    let sum = p1 + p2;
    println!("{:?}", sum);
}

std::ffi（外部函数接口模块）：

use std::ffi::CString;
use std::os::raw::c_char;

extern "C" {
    fn my_function(arg: *const c_char);
}

fn main() {
    let input = CString::new("Hello, Rust!").unwrap();
    unsafe {
        my_function(input.as_ptr());
    }
}

std::panic（panic 处理模块）：

fn main() {
    let result = std::panic::catch_unwind(|| {
        panic!("Oops!");
    });

    match result {
        Ok(_) => println!("No panic occurred."),
        Err(_) => println!("A panic occurred."),
    }
}

std::marker（标记模块）：

fn process<T: MyTrait>(data: T) {
    // 处理实现了 MyTrait 的类型
}

trait MyTrait {}

struct MyType;

impl MyTrait for MyType {}

fn main() {
    let value = MyType;
    process(value);
}

std::cell（可变内部可变性模块）：

use std::cell::RefCell;

fn main() {
    let counter = RefCell::new(0);
    *counter.borrow_mut() += 1;
    println!("Counter: {:?}", counter.borrow());
}