Rust初学知识点快速记忆

Rust 入门知识点

1. 所有权 (Ownership)

核心概念：每个值在 Rust 中有且只有一个所有者。当所有者离开作用域时，值会被自动销毁，避免内存泄漏。

示例：

rust 复制代码

fn main() {
    let s1 = String::from("Hello");  // s1 是 String 的所有者
    let s2 = s1;  // 所有权转移，s1 不再有效

    // println!("{}", s1); // 编译错误：s1 已被转移
    println!("{}", s2);  // 输出: Hello
}

2. 借用 (Borrowing)

核心概念：借用允许其他代码引用数据而不改变其所有权。借用分为不可变借用和可变借用。

示例：

rust 复制代码

fn main() {
    let s = String::from("Hello");

    // 不可变借用
    let len = calculate_length(&s);  // 使用 &s 引用 s
    println!("Length: {}", len);  // 输出: Length: 5

    // 可变借用
    let mut s_mut = String::from("Hello");
    change_string(&mut s_mut);
    println!("Changed: {}", s_mut);  // 输出: Changed: Hello, Rust!
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

fn change_string(s: &mut String) {
    s.push_str(", Rust!");
}

3. 生命周期 (Lifetimes)

核心概念：生命周期确保借用的数据在有效范围内，避免出现悬空指针。

示例：

rust 复制代码

fn main() {
    let r;                // 生命期标注
    {
        let s = String::from("Hello");
        r = &s;           // r 借用 s
    }
    // println!("{}", r);  // 编译错误：s 在这里已经不再有效
}

4. 结构体 (Struct)

核心概念：结构体是自定义数据类型，用于封装相关的数据。

示例：

rust 复制代码

struct Person {
    name: String,
    age: u32,
}

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

    println!("Name: {}, Age: {}", person.name, person.age);
}

5. 枚举 (Enum)

核心概念：枚举类型允许你定义多个相关的变体。

示例：

rust 复制代码

enum Direction {
    Up,
    Down,
    Left,
    Right,
}

fn move_player(direction: Direction) {
    match direction {
        Direction::Up => println!("Moving up"),
        Direction::Down => println!("Moving down"),
        Direction::Left => println!("Moving left"),
        Direction::Right => println!("Moving right"),
    }
}

fn main() {
    let dir = Direction::Up;
    move_player(dir);
}

6. 模式匹配 (Pattern Matching)

核心概念 ：match 语句用于对不同的模式进行匹配，非常适合和枚举配合使用。

示例：

rust 复制代码

enum Color {
    Red,
    Green,
    Blue,
}

fn print_color(color: Color) {
    match color {
        Color::Red => println!("The color is Red"),
        Color::Green => println!("The color is Green"),
        Color::Blue => println!("The color is Blue"),
    }
}

fn main() {
    let color = Color::Green;
    print_color(color);
}

7. 错误处理 (Error Handling)

核心概念 ：Rust 使用 Result 类型来处理错误，Result 有两个变体：Ok 和 Err。

示例：

rust 复制代码

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("Cannot divide by zero".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    match divide(10, 2) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

8. 闭包 (Closure)

核心概念：闭包是可以捕获外部环境变量的匿名函数。

示例：

rust 复制代码

fn main() {
    let x = 5;
    let add_x = |y| x + y;  // 闭包，捕获 x
    println!("{}", add_x(10));  // 输出: 15
}

9. 并发 (Concurrency)

核心概念：Rust 原生支持并发，并通过线程保证内存安全。

示例：

rust 复制代码

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("Hello from the thread!");
    });

    handle.join().unwrap();  // 等待线程完成
}

10. 模块和包 (Modules and Packages)

核心概念 ：Rust 使用模块来组织代码，并且可以使用 Cargo 来管理项目和依赖。

示例：

rust 复制代码

mod my_module {
    pub fn greet() {
        println!("Hello from my_module!");
    }
}

fn main() {
    my_module::greet();  // 调用模块中的函数
}

11. Cargo 与依赖管理

核心概念 ：Cargo 是 Rust 的构建工具和包管理器，用于创建、构建、测试和发布项目。

示例：

bash 复制代码

cargo new my_project  # 创建新项目
cargo build           # 编译项目
cargo test            # 运行测试