Rust入门掌握这50个写法就够了Rust，被誉为系统编程语言的新星，以其内存安全和高效的并发控制吸引了大量开发者的关注

Rust，被誉为系统编程语言的新星，以其内存安全和高效的并发控制吸引了大量开发者的关注。对于初学者来说，要想快速上手并灵活运用Rust，掌握一些基本的写法和技巧至关重要。以下是Rust入门的50个关键写法的前十个，帮助你轻松迈出Rust编程的第一步。

各位美女帅哥只要老实把下面的代码都敲一遍，以后就不要再说没听过 Rust 了吧~

1. Hello, World!

这是学习任何新编程语言的起点。在Rust中，你可以这样写：

fn main() {
    println!("Hello, World!");
}

2. 变量声明

在Rust中，你可以使用let关键字来声明变量。默认情况下，这些变量是不可变的。

let x = 5; // 不可变变量

3. 可变变量

如果你需要一个可以修改的变量，可以在let之后添加mut关键字。

let mut y = 10; // 可变变量
y = 15; // 修改变量值

4. 数据类型

Rust有多种内置的数据类型，如整数、浮点数、布尔值等。

let i32_num: i32 = -12345; // 32位有符号整数
let f64_num: f64 = 3.14; // 64位浮点数
let is_true: bool = true; // 布尔值

5. 元组

元组是一种可以包含多种不同类型元素的复合数据类型。

let tup = (500, "hello", 4.5); // 元组包含整数、字符串和浮点数

6. 数组

数组是相同类型元素的连续集合。

let arr = [1, 2, 3, 4, 5]; // 包含5个整数的数组

7. 切片

切片是对数组的一部分的引用。

let slice = &arr[1..3]; // 引用数组的第2和第3个元素（索引从0开始）

8. 控制流 - 条件语句

使用if、else if和else来控制程序的流程。

let num = 3;
if num > 5 {
    println!("大于5");
} else if num == 5 {
    println!("等于5");
} else {
    println!("小于或等于5");
}

9. 控制流 - 循环

使用for循环来遍历集合中的元素。

for i in 0..5 { // 遍历0到4的整数序列
    println!("{}", i);
}

10. 函数定义

在Rust中，你可以定义自己的函数来执行特定的任务。

fn greet(name: &str) {
    println!("Hello, {}!", name); // 打印问候语
}
greet("Rustacean"); // 调用函数并传递参数

11. 函数返回值

在Rust中，你可以定义有返回值的函数。

fn add(a: i32, b: i32) -> i32 {
    a + b // 返回两个整数的和
}
let sum = add(5, 7); // 调用函数并将结果存储在变量sum中

12. 引用和借用

Rust通过引用（&）来借用变量的值，而不直接获取其所有权。

fn print_value(value: &i32) {
    println!("Value: {}", value);
}
let x = 10;
print_value(&x); // 通过引用传递变量x

13. 可变引用

可变引用允许你修改引用的值。

fn modify_value(value: &mut i32) {
    *value += 1; // 修改引用的值
}
let mut y = 20;
modify_value(&mut y); // 通过可变引用传递变量y

14. 结构体（Structs）

结构体允许你定义一个复合数据类型，可以包含多个字段。

struct Person {
    name: String,
    age: u8,
}
let person = Person { name: "Alice".to_string(), age: 30 };

15. 枚举（Enums）

枚举类型用于定义一组命名的值。

enum Color {
    Red,
    Green,
    Blue,
}
let my_color = Color::Red; // 使用枚举的一个变体

16. 模式匹配（Match）

match表达式允许你根据枚举或其他类型的值进行分支处理。

match my_color {
    Color::Red => println!("It's red!"),
    Color::Green => println!("It's green!"),
    Color::Blue => println!("It's blue!"),
}

17. Option枚举

Option是一个表示可能有值或没有值的枚举。

enum Option<T> {
    Some(T),
    None,
}
let optional_value: Option<i32> = Some(42); // 或者None表示没有值

18. Result类型

Result类型用于处理可能出错的操作，它包含Ok或Err两个变体。

enum Result<T, E> {
    Ok(T),
    Err(E),
}
fn divide(a: i32, b: i32) -> Result<i32, &'static str> {
    if b == 0 {
        Err("Division by zero!")
    } else {
        Ok(a / b)
    }
}

19. 泛型

泛型允许你编写适用于多种类型的函数或结构体。

fn largest<T: Ord>(a: T, b: T) -> T {
    if a > b { a } else { b }
}
let largest_i32 = largest(5i32, 10i32); // 泛型函数用于i32类型

20. 闭包（Closures）和迭代器（Iterators）

闭包是可以捕获环境的匿名函数，而迭代器提供了一种遍历集合元素的方法。

let nums = vec![1, 2, 3, 4, 5];
let squares = nums.iter().map(|x| x * x).collect::<Vec<_>>(); // 使用闭包和迭代器计算平方并收集结果

21. 闭包作为函数参数

在Rust中，你可以将闭包作为函数的参数传递。

fn apply<F>(f: F, x: i32) -> i32 where F: Fn(i32) -> i32 {
    f(x)
}
let result = apply(|x| x * 2, 5); // 传递闭包，将数字乘以2

22. 使用标准库中的集合

Rust的标准库提供了多种集合类型，如Vec<T>、HashMap<K, V>等。

let mut vec = Vec::new();
vec.push(1);
vec.push(2);

23. 字符串操作

在Rust中，字符串是不可变的，但你可以通过String类型来创建和修改字符串。

let mut s = String::from("Hello");
s.push_str(", World!"); // 修改字符串

24. 使用match进行错误处理

match可以用于处理Result类型的错误。

let result: Result<i32, &str> = Ok(42); // 或者Err("Error message")
match result {
    Ok(value) => println!("Value: {}", value),
    Err(e) => println!("Error: {}", e),
}

25. 生命周期

Rust中的生命周期参数用于指定引用的有效范围，确保数据竞争和悬垂引用的安全。

fn print_longest<'a>(x: &'a str, y: &'a str) {
    if x.len() > y.len() {
        println!("{} is longer", x);
    } else {
        println!("{} is longer", y);
    }
}

26. 使用use语句导入模块

你可以使用use语句来导入模块，以便在代码中使用它们。

use std::collections::HashMap;
let mut map = HashMap::new();
map.insert("key", "value");

27. 实现特征（Traits）

在Rust中，你可以通过实现特征来为类型添加行为。

trait Greeting {
    fn greet(&self);
}
struct Person;
impl Greeting for Person {
    fn greet(&self) {
        println!("Hello!");
    }
}
let p = Person;
p.greet(); // 调用实现的特征方法

28. 宏（Macros）

Rust支持宏，它们允许你在编译时生成代码。

macro_rules! print_hello {
    () => {
        println!("Hello from macro!");
    };
}
print_hello!(); // 调用宏

29. 线程安全

Rust提供了多种同步原语，如Mutex和Arc，以确保线程安全。

use std::sync::{Arc, Mutex};
let counter = Arc::new(Mutex::new(0));
// 在多线程环境中安全地修改counter的值...

30. 测试

Rust内置了强大的测试框架，你可以使用#[test]属性来编写测试函数。

#[test]
fn test_addition() {
    assert_eq!(1 + 1, 2); // 断言1+1等于2，用于测试
}

31. 条件编译

Rust支持条件编译，允许你根据某些条件来编译特定的代码块。

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}

32. 文档注释

Rust使用特定的注释语法来生成文档。

/// 这是一个文档注释，用于描述下面的函数。
/// # 示例
/// ```
/// println!("Hello, world!");
/// ```
pub fn hello_world() {
    println!("Hello, world!");
}

33. 外部依赖管理

使用Cargo.toml文件来管理项目的外部依赖。

[dependencies]
rand = "0.8"

34. 模块系统

Rust有一个强大的模块系统，允许你将代码组织成多个文件和模块。

// lib.rs
pub mod my_module;

// my_module.rs
pub fn my_function() {
    println!("This is my function in my_module");
}

35. 范围

Rust支持使用范围来表示一系列的数值。

for i in 1..=5 {
    println!("{}", i); // 打印从1到5的数字
}

36. 所有权和借用

理解Rust的所有权系统和借用检查器是编写安全Rust代码的关键。

fn take_ownership(v: Vec<i32>) {
    // ...
}

fn borrow_vector(v: &Vec<i32>) {
    // ...
}

37. 默认参数和可变参数

Rust函数支持默认参数和可变参数列表。

fn function_with_default(param: i32 = 10) {
    // ...
}

fn function_with_variadic_params(params: &[&str]) {
    // ...
}

38. 静态生命周期

在Rust中，你可以使用静态生命周期来指定某个引用的生命周期与整个程序的执行时间一样长。

static MY_CONST: &'static str = "Hello, world!";

39. 内部可变性和单元化

Rust提供了Cell和RefCell等类型，允许你在不违反Rust所有权规则的情况下实现内部可变性。

use std::cell::Cell;
let x = Cell::new(1);
x.set(x.get() + 1); // 内部可变性，不需要mut关键字

40. 不安全代码

在某些情况下，你可能需要编写不安全代码来执行底层操作。Rust提供了unsafe关键字来处理这些情况。

unsafe fn dangerous_function() {
    // 执行不安全操作...
}

unsafe {
    dangerous_function(); // 必须在unsafe块中调用不安全函数
}

41. 泛型

Rust支持泛型编程，允许你编写灵活且可重用的代码。

fn largest<T: Ord>(list: &[T]) -> T {
    let mut largest = &list[0];
    for item in list {
        if item > *largest {
            largest = item;
        }
    }
    *largest
}

42. 特性（Trait）对象

特性对象允许你使用动态分发来处理具有相同特性的多种类型。

trait Animal {
    fn make_sound(&self);
}

struct Dog;
impl Animal for Dog {
    fn make_sound(&self) {
        println!("Woof!");
    }
}

fn animal_sound(animal: &dyn Animal) {
    animal.make_sound();
}

43. 关联函数和关联类型

在Rust中，你可以在特性中定义关联函数和关联类型。

trait Graph {
    type Node;
    fn add_node(&mut self, node: Self::Node);
}

44. 从错误中恢复

使用?操作符可以方便地处理可能返回Err的结果。

fn read_file(path: &str) -> Result<String, std::io::Error> {
    let content = std::fs::read_to_string(path)?; // 错误处理被简化
    Ok(content)
}

45. 自定义错误类型

你可以定义自己的错误类型来实现更复杂的错误处理逻辑。

enum MyError {
    Io(std::io::Error),
    Parse(std::num::ParseIntError),
}

impl From<std::io::Error> for MyError {
    fn from(err: std::io::Error) -> MyError {
        MyError::Io(err)
    }
}
// 类似地实现其他错误类型的转换...

46. 使用Option和Result进行错误处理

Rust使用Option<T>和Result<T, E>来表示可能失败的操作。

fn divide(a: f64, b: f64) -> Result<f64, &'static str> {
    if b == 0.0 {
        Err("Cannot divide by zero")
    } else {
        Ok(a / b)
    }
}

47. 迭代器

Rust的迭代器提供了一种处理集合中元素的高效方式。

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

48. 并发与并行

Rust提供了强大的并发和并行支持，如线程、消息传递和异步I/O。

use std::thread;
let handle = thread::spawn(|| {
    println!("Running in a new thread!");
});
handle.join().unwrap();

49. 结构体更新语法

Rust支持结构体更新语法，可以方便地创建结构体的新实例，同时保留部分字段的值。

struct Point { x: i32, y: i32 }
let point = Point { x: 1, y: 2 };
let new_point = Point { x: 5, ..point }; // y字段保持不变，x字段更新为5

50. 宏的高级用法

Rust的宏系统非常强大，支持声明性宏和过程性宏，可以实现复杂的代码生成和抽象。

macro_rules! print_vec {
    ($($x:expr),*) => {
        println!("Vector: [{:?}]", vec![$($x),*]);
    }
}
print_vec!(1, 2, 3); // 输出：Vector: [1, 2, 3]