Rust 是一种注重安全性、性能和并发性的系统编程语言，由 Mozilla 开发。它通过所有权系统（Ownership）、生命周期（Lifetimes）和借用（Borrowing）等创新概念，在不牺牲性能的前提下提供内存安全保障。以下是 Rust 语法的核心特性简介：
1. 基础语法
变量声明与不可变性
Rust 变量默认不可变（Immutable），需显式声明 mut 变为可变：
rust
let x = 5; // 不可变变量
let mut y = 10; // 可变变量
y += 5; // 合法：y 是可变的
数据类型
Rust 是静态类型语言，但支持类型推断：
rust
let integer: i32 = 42; // 32位有符号整数
let float: f64 = 3.14; // 64位浮点数
let boolean: bool = true; // 布尔值
let character: char = '🦀'; // Unicode 字符（4字节）
2. 复合类型
元组（Tuple）
rust
let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup; // 解构赋值
println!("y 的值: {}", y); // 输出: 6.4
数组（Array）
数组长度固定，类型统一：
rust
let a = [1, 2, 3, 4, 5]; // 自动类型推断为 [i32; 5]
let b: [i32; 3] = [1, 2, 3]; // 显式指定类型和长度
let first_element = a[0]; // 访问元素
3. 控制流
条件表达式
rust
let number = 3;
if number < 5 {
println!("条件为真");
} else {
println!("条件为假");
}
// 条件表达式可用于赋值
let result = if number % 2 == 0 {
"偶数"
} else {
"奇数"
}; // 注意分号：整个 if-else 是一个表达式
循环
rust
// 无限循环
loop {
println!("这会无限执行，直到 break");
break; // 退出循环
}
// while 循环
let mut counter = 0;
while counter < 3 {
println!("计数器: {}", counter);
counter += 1;
}
// for 循环遍历数组
let a = [10, 20, 30];
for element in a.iter() {
println!("元素: {}", element);
}
4. 函数
rust
fn add(a: i32, b: i32) -> i32 { // 参数类型和返回值类型必须明确
a + b // 无分号：隐式返回最后一个表达式的值
}
fn main() {
let result = add(3, 5);
println!("3 + 5 = {}", result); // 输出: 8
}
5. 所有权系统（核心特性）
Rust 通过所有权规则管理内存安全：
-
每个值都有一个变量作为其所有者。
-
同一时间，一个值只能有一个所有者。
-
当所有者离开作用域，值会被丢弃（drop） 。
rust
fn main() {
let s1 = String::from("hello"); // s1 拥有字符串
let s2 = s1; // 所有权从 s1 转移到 s2
// println!("s1: {}", s1); // 错误！s1 已失去所有权
takes_ownership(s2); // s2 的所有权转移到函数参数
// println!("s2: {}", s2); // 错误！s2 不再有效
let x = 5; // 整数是 Copy 类型（无需所有权转移）
makes_copy(x); // x 的值被复制到函数参数
println!("x: {}", x); // 合法：x 仍然有效
}
fn takes_ownership(s: String) {
println!("{}", s);
} // s 离开作用域，内存被释放
fn makes_copy(x: i32) {
println!("{}", x);
} // i32 实现了 Copy trait，无需释放内存
6. 借用与引用
通过引用（&）允许临时使用值而不获取所有权：
rust
fn main() {
let s1 = String::from("hello");
let len = calculate_length(&s1); // 借用 s1 的引用，不转移所有权
println!("字符串长度: {}", len);
println!("s1: {}", s1); // 合法：s1 仍拥有所有权
}
fn calculate_length(s: &String) -> usize { // 参数为字符串引用
s.len()
} // s 离开作用域，但不拥有所有权，因此不释放内存
7. 结构体（Struct）
rust
struct User {
username: String,
email: String,
active: bool,
sign_in_count: u64,
}
fn main() {
let user1 = User {
email: String::from("user@example.com"),
username: String::from("user123"),
active: true,
sign_in_count: 1,
};
// 访问结构体字段
println!("用户邮箱: {}", user1.email);
}
8. 枚举（Enum）与模式匹配
rust
enum IpAddrKind {
V4,
V6,
}
struct IpAddr {
kind: IpAddrKind,
address: String,
}
fn main() {
let home = IpAddr {
kind: IpAddrKind::V4,
address: String::from("127.0.0.1"),
};
// 模式匹配
match home.kind {
IpAddrKind::V4 => println!("IPv4 地址"),
IpAddrKind::V6 => println!("IPv6 地址"),
}
}
9. 错误处理
Rust 使用 Result<T, E> 枚举处理可能的错误：
rust
use std::fs::File;
fn main() {
let f = File::open("hello.txt");
let f = match f {
Ok(file) => file,
Err(error) => panic!("打开文件失败: {:?}", error),
};
}
10. 特性（Trait）
类似于接口，定义行为规范：
rust
trait Summary {
fn summarize(&self) -> String;
}
struct NewsArticle {
headline: String,
author: String,
}
impl Summary for NewsArticle {
fn summarize(&self) -> String {
format!("{}, by {}", self.headline, self.author)
}
}
fn main() {
let article = NewsArticle {
headline: String::from("重大新闻"),
author: String::from("记者A"),
};
println!("文章摘要: {}", article.summarize());
}
总结
Rust 的核心优势在于其独特的内存安全模型（无需 GC）、高性能和强大的类型系统。虽然入门门槛较高，但其严格的编译时检查能帮助开发者避免许多运行时错误。对于追求系统级性能和安全性的项目（如操作系统、网络服务、嵌入式设备等），Rust 是理想选择。
