Rust 基础语法（长文解析）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

前言

Rust 是一门强调内存安全与并发安全的系统级编程语言，自 2010 年诞生以来，因其独特的所有权机制和零成本抽象特性，逐渐成为开发高性能、高可靠性软件的首选语言之一。无论是构建操作系统、网络服务，还是开发嵌入式系统，Rust 都展现出强大的生命力。对于编程初学者和中级开发者来说，掌握 Rust 的基础语法是解锁其高级特性的第一步。本文将通过循序渐进的方式，结合实际案例，帮助读者快速理解 Rust 的核心语法与设计理念。

变量与作用域：数据的“管理员”

变量声明与不可变性

在 Rust 中，变量默认是不可变的（immutable）。这与 JavaScript 或 Python 等动态语言形成鲜明对比。通过 let 关键字声明变量时，若未使用 mut 标记，变量值将无法修改：

let name = "Alice";  
// name = "Bob"; // 这里会报错：cannot assign twice to immutable variable `name`  

这种设计并非限制灵活性，而是通过强制不可变性减少程序中的意外副作用。若确实需要可变性，只需添加 mut：

let mut count = 0;  
count += 1; // 合法操作  

数据类型与类型推断

Rust 是静态类型语言，但支持类型推断。开发者无需显式指定类型，编译器会根据初始值自动推导：

let score = 95; // i32（默认整数类型）  
let temperature = 26.5; // f64（默认浮点类型）  

若需显式指定类型，可通过 : 后跟类型名实现：

let hex: u32 = 0xff; // 明确声明为无符号32位整数  

作用域与阴影变量

变量的作用域由其声明位置决定。Rust 允许在不同作用域中重复使用相同变量名，但通过 shadowing（阴影化）机制，新变量会覆盖旧变量：

let x = 5; // i32  
{  
    let x = x * 2; // 允许在内部作用域重新声明  
    println!("Inner x: {}", x); // 10  
}  
println!("Outer x: {}", x); // 仍为5，未修改原始变量  

控制结构：程序的“交通指挥官”

条件判断：if 和 else

Rust 的 if 表达式返回值可以赋给变量，这与其他语言的 if 语句不同：

let is_raining = true;  
let plan = if is_raining {  
    "Stay indoors"  
} else {  
    "Go for a walk"  
};  
println!("Today's plan: {}", plan);  

循环结构：loop、while 和 for

Rust 提供三种循环：

1. 无限循环 loop：需通过 break 退出：

   loop {  
       println!("This will run forever...");  
       break; // 必须显式终止  
   }  
   

2. 条件循环 while：类似其他语言：

   let mut num = 3;  
   while num > 0 {  
       println!("{}!", num);  
       num -= 1;  
   }  
   

3. 迭代循环 for：遍历集合或范围：

   for i in 1..=5 { // 包含5  
       println!("{}", i); // 1,2,3,4,5  
   }  
   

函数：代码的“乐高积木”

函数定义与调用

函数通过 fn 关键字定义，返回值类型用 -> 指定：

fn calculate_area(length: f64, width: f64) -> f64 {  
    length * width  
}  

fn main() {  
    let area = calculate_area(5.5, 3.2);  
    println!("Area: {}", area); // 17.6  
}  

参数传递与所有权

函数参数的传递遵循 Rust 的所有权规则。若参数是变量，则调用后原变量可能失效（取决于是否移动）：

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

fn main() {  
    let message = String::from("Hello");  
    print_string(message); // message 的所有权被移动到函数内部  
    // println!("{}", message); // 此处报错：value borrowed here after move  
}  

闭包：迷你函数

闭包允许将函数作为参数传递，语法简洁：

let numbers = vec![1, 2, 3];  
let even_numbers: Vec<_> = numbers.into_iter()  
    .filter(|&x| x % 2 == 0) // 闭包检查偶数  
    .collect();  

内存管理：所有权与借用

所有权机制

Rust 的核心创新是“所有权”（Ownership），它通过编译期检查确保内存安全，避免空指针、数据竞争等问题。例如，当字符串 String 被赋值给新变量时，原变量将失效：

let s1 = String::from("Hello");  
let s2 = s1; // s1 的所有权被转移给 s2  
// println!("{}", s1); // 报错：use of moved value  

引用与借用

通过 & 符号创建引用，实现对数据的“借用”而非转移所有权：

let s = String::from("Rust");  
let first_word = find_first_word(&s); // 借用 s  
// ...  
fn find_first_word(s: &String) -> usize {  
    // 处理逻辑  
}  

可变引用规则

Rust 禁止在同一个作用域内存在多个可变引用，以避免数据竞争：

let mut data = vec![1, 2, 3];  
let mut_ref1 = &mut data; // 允许  
// let mut_ref2 = &mut data; // 报错：cannot borrow `data` as mutable more than once at a time  

错误处理：优雅的“问题解决者”

Result 类型

Rust 使用 Result<T, E> 枚举处理可恢复错误，其中 Ok 表示成功，Err 表示失败：

use std::fs::File;  

fn read_file() -> Result<String, std::io::Error> {  
    let f = File::open("data.txt")?; // 若出错，立即返回 Err  
    // ...读取文件内容  
    Ok("Content".to_string())  
}  

panic! 与不可恢复错误

对于无法继续执行的情况，使用 panic! 宏触发程序崩溃：

fn divide(a: i32, b: i32) -> i32 {  
    if b == 0 {  
        panic!("Division by zero!");  
    }  
    a / b  
}  

高级特性：泛型与模式匹配

泛型函数

通过 <T> 声明泛型参数，使函数或结构体可操作多种类型：

fn first_char<T: AsRef<str>>(text: T) -> Option<char> {  
    text.as_ref().chars().next()  
}  

let first = first_char("Hello"); // Some('H')  

模式匹配

match 表达式通过模式匹配处理多种情况，避免复杂的 if-else 链：

enum Direction { North, South, East, West }  

fn describe(direction: Direction) {  
    match direction {  
        Direction::North => println!("Going North!"),  
        Direction::South => println!("Going South!"),  
        _ => println!("Other direction"), // _ 匹配所有未列出的值  
    }  
}  

结论

Rust 的基础语法融合了内存安全、所有权机制与现代化编程范式，为开发者提供了高效、可靠的编程体验。从变量与作用域的严谨设计，到函数与控制结构的灵活组合，再到所有权与错误处理的深度集成，Rust 的每一项特性都旨在降低系统级开发的复杂性。

对于初学者，建议从简单项目入手，例如实现一个命令行工具或小型网络服务，逐步理解 Rust 的所有权模型与生命周期。中级开发者则可尝试结合 Rust 的异步编程（async/await）和并发特性，探索更复杂的系统架构。掌握 Rust 基础语法后，开发者将能更从容地应对高性能、多线程场景的挑战，这也是 Rust 在云原生、区块链等领域备受青睐的原因所在。

记住，Rust 的学习曲线虽陡峭，但其带来的安全性和性能优势，将使开发者在长期项目维护中受益匪浅。现在，不妨动手编写第一个 Rust 程序，开启这段充满挑战与收获的旅程吧！