**如果你喜欢这篇文章，请在 YouTube 上订阅我**

🦀 终极 Rust 编程语言超级教程 🚀

本指南旨在让您成为 **Rust 专家** — 无论您是刚入门还是想要深入了解高级功能。我们将涵盖 **Rust 的各个方面**，从最基础的到高级并发、内存管理、Web 开发等等。

🌟 为什么要学习 Rust？

Rust 因其独特的组合而脱颖而出：

🛠️ 设置 Rust

安装 Rust

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

source $HOME/.cargo/env

rustc --version
   cargo --version

🌱 第 1 章：Rust 基础知识

让我们从 Rust 的**基础概念**开始。

🔤 1.1 变量和常量

let x = 5;
  println!("x: {}", x);  
  // x = 10; // Error: Cannot reassign

let mut y = 10;
  y += 5;
  println!("y: {}", y);

const PI: f64 = 3.14159265359;  
  println!("Value of PI: {}", PI);

📚 1.2 Rust 中的数据类型

Rust 有一个**静态类型系统**，具有显式和推断类型。

🔗 第二章：所有权、借用和生命周期

Rust 的**所有权模型**是其内存安全的基石。

📦2.1 所有权规则

fn main() {
    let s = String::from("hello");
    takes_ownership(s);  
    // s is no longer valid here
}

fn takes_ownership(s: String) {
    println!("{}", s);
}

➕ 2.2 借用和引用

借用允许多个引用而无需转移所有权。

fn main() {
    let s = String::from("hello");
    print_length(&s);
    println!("Still valid: {}", s);
}

fn print_length(s: &String) {
    println!("Length: {}", s.len());
}

🔒 2.3 可变引用

Rust 一次只允许一个可变引用：

fn main() {
    let mut s = String::from("hello");
    change(&mut s);
    println!("Changed: {}", s);
}

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

🔗 2.4 生命周期

生命周期可防止悬垂引用。

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}
fn main() {
    let s1 = "long string";
    let s2 = "short";
    println!("Longest: {}", longest(s1, s2));
}

📈 第 3 章：高级概念

🔄 3.1 模式匹配

Rust 的 `match` 是一个强大的构造：

fn main() {
    let number = 6;
    match number {
        1 => println!("One"),
        2..=5 => println!("Between Two and Five"),
        _ => println!("Something else"),
    }
}

🔧 3.2 错误处理

fn divide(x: i32, y: i32) -> Result {
      if y == 0 {
          Err(String::from("Cannot divide by zero"))
      } else {
          Ok(x / y)
      }
  }
  fn main() {
      match divide(10, 2) {
          Ok(res) => println!("Result: {}", res),
          Err(e) => println!("Error: {}", e),
      }
  }

第四章：Rust 中的并发

4.1 线程

Rust 的线程是内存安全的：

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("Thread: {}", i);
        }
    });

    handle.join().unwrap();
}

🌐 第 5 章：现实世界的 Rust 项目

🚀 5.1 构建命令行工具

让我们构建一个**简单的 CLI** 来计算文件中的单词数：

use std::env;
use std::fs;

fn main() {
    let args: Vec = env::args().collect();
    let filename = &args[1];
    let content = fs::read_to_string(filename).unwrap();
    let word_count = content.split_whitespace().count();
    println!("Word count: {}", word_count);
}

🛠️ 5.2 使用 Rocket 进行 Web 开发

Rust 的 **Rocket** 框架非常适合构建 Web 应用程序：

#[macro_use] extern crate rocket;

#[get("/")]
fn index() -> &'static str {
    "Hello, world!"
}

fn main() {
    rocket::ignite().mount("/", routes![index]).launch();
}

📜 福利：Rust 学习路线图

本指南只是开始。Rust 是一种强大的语言，可以伴随您成长。继续练习、构建项目并深入了解 Rust 生态系统。祝您编码愉快！🦀✨