初学 Rust 的开发者往往容易踩坑，本文总结了十个常见错误，帮你写出更好的 Rust 代码。让我们一起深入了解这些问题及其解决方案。
引言
Rust 作为一门安全且高效的系统级编程语言，其独特的所有权系统和严格的编译规则常常让开发者感到困惑。本文将详细介绍 Rust 开发中的十个常见错误，并提供相应的解决方案，帮助你更好地掌握 Rust 编程。
1. 过度使用 clone() 而不是借用
很多开发者为了避免所有权问题，习惯性地使用 .clone()，这会带来不必要的性能开销。合理使用借用可以提高程序效率。
// 错误示例：不必要的 clone
let data = vec![1, 2, 3];
let sum = data.clone().iter().sum::<i32>();
// 正确示例：使用借用
let data = vec![1, 2, 3];
let sum = data.iter().sum::<i32>(); // 直接使用引用迭代
2. 忽视错误处理
过度使用 unwrap() 或 expect() 而不妥善处理错误情况，可能导致程序在运行时崩溃。
// 错误示例：直接 unwrap 可能导致程序崩溃
let file = File::open("config.txt").unwrap();
// 正确示例：优雅地处理错误
let file = File::open("config.txt").unwrap_or_else(|err| {
eprintln!("打开文件失败：{err}");
process::exit(1);
});
// 更好的示例：使用 ? 运算符
fn read_config() -> Result<String, std::io::Error> {
let mut file = File::open("config.txt")?;
let mut contents = String::new();
file.read_to_string(&mut contents)?;
Ok(contents)
}
3. 使用循环而不是迭代器
手动管理索引进行循环，而不是使用 Rust 强大的迭代器方法。迭代器提供了更简洁、更安全的代码。
// 错误示例：手动循环处理
let mut squared = Vec::new();
for x in vec![1, 2, 3] {
squared.push(x * x);
}
// 正确示例：使用迭代器
let squared: Vec<_> = (1..=3)
.into_iter()
.map(|x| x * x)
.collect();
// 过滤和转换的例子
let even_squares: Vec<_> = (1..=10)
.into_iter()
.filter(|x| x % 2 == 0) // 只保留偶数
.map(|x| x * x) // 求平方
.collect();
4. 误解所有权和借用规则
尝试修改已借用的值或误解 Rust 的严格别名规则。理解所有权系统是写好 Rust 的关键。
// 错误示例：多重可变借用
let mut data = vec![1, 2, 3];
let r1 = &mut data;
let r2 = &mut data; // 错误：第二次可变借用！
// 正确示例：顺序可变借用
let mut data = vec![1, 2, 3];
{
let r1 = &mut data;
r1.push(4);
} // r1 在这里结束
let r2 = &mut data; // 现在可以进行新的借用
r2.push(5);
// 正确示例：同时使用可变和不可变引用
let mut data = vec![1, 2, 3];
let r1 = &data; // 不可变引用
let r2 = &data; // 可以有多个不可变引用
println!("{} {}", r1[0], r2[0]);
let r3 = &mut data; // 之前的不可变引用已经结束，可以创建可变引用
r3.push(4);
5. 过度复杂化生命周期标注
在编译器能够自动推断的地方添加显式的生命周期标注，使代码不必要地复杂。
// 错误示例：不必要的生命周期标注
fn get_first<'a>(s: &'a str) -> &'a str {
&s[..1]
}
// 正确示例：让 Rust 自动推断生命周期
fn get_first(s: &str) -> &str {
&s[..1]
}
// 需要显式生命周期的正确示例
struct NamedString<'a> {
name: &'a str,
value: String,
}
6. 回避不必要的 unsafe 代码
有些开发者完全回避 unsafe 代码，即使在某些场景下它是最佳选择。
// 正确使用 unsafe 的示例：与 C 语言交互
use std::mem::MaybeUninit;
unsafe {
// 分配内存
let mut arr: MaybeUninit<[i32; 10]> = MaybeUninit::uninit();
// 初始化内存
let ptr = arr.as_mut_ptr() as *mut i32;
for i in 0..10 {
*ptr.add(i) = i as i32;
}
// 使用初始化后的数组
let initialized_arr = arr.assume_init();
println!("数组第一个元素：{}", initialized_arr[0]);
}
7. 滥用 unwrap()
在整个代码库中过度使用 unwrap()，而不是采用更优雅的错误处理方式。
// 错误示例：过度使用 unwrap
fn process_data() -> i32 {
let file_content = fs::read_to_string("data.txt").unwrap();
let number = file_content.parse::<i32>().unwrap();
number * 2
}
// 正确示例：使用 Result 和 ？运算符
fn process_data() -> Result<i32, Box<dyn Error>> {
let file_content = fs::read_to_string("data.txt")?;
let number = file_content.parse::<i32>()?;
Ok(number * 2)
}
// 更好的示例：提供详细的错误处理
use thiserror::Error;
#[derive(Error, Debug)]
enum DataError {
#[error("读取文件失败: {0}")]
IoError(#[from] std::io::Error),
#[error("解析数字失败: {0}")]
ParseError(#[from] std::num::ParseIntError),
}
fn process_data() -> Result<i32, DataError> {
let file_content = fs::read_to_string("data.txt")?;
let number = file_content.parse::<i32>()?;
Ok(number * 2)
}
8. 不利用异步编程生态系统
没有充分利用 Rust 丰富的异步编程生态系统，如 tokio 或 async-std。
// 正确示例：使用 tokio 进行异步编程
use tokio;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// 创建多个并发任务
let task1 = tokio::spawn(async {
// 模拟耗时操作
tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
"任务1完成"
});
let task2 = tokio::spawn(async {
tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
"任务2完成"
});
// 等待所有任务完成
let (result1, result2) = tokio::join!(task1, task2);
println!("{}, {}", result1?, result2?);
Ok(())
}
9. 过早优化代码
在没有性能分析的情况下进行优化，可能导致代码复杂化而没有实际收益。
// 错误示例：过早优化
struct Cache {
data: HashMap<String, Vec<u8>>,
// 添加了复杂的缓存策略但没有实际需求
last_accessed: HashMap<String, SystemTime>,
max_items: usize,
}
// 正确示例：先实现基本功能，需要时再优化
struct Cache {
data: HashMap<String, Vec<u8>>,
}
impl Cache {
// 简单直接的实现
fn get(&self, key: &str) -> Option<&Vec<u8>> {
self.data.get(key)
}
fn set(&mut self, key: String, value: Vec<u8>) {
self.data.insert(key, value);
}
}
10. 忽视 Rust 惯用法
用其他语言的编程思维写 Rust 代码，而不是遵循 Rust 的惯用法。
// 错误示例：使用其他语言的思维
fn process_items(items: Vec<i32>) -> Vec<i32> {
let mut result = Vec::new();
for i in 0..items.len() {
if items[i] % 2 == 0 {
result.push(items[i] * 2);
}
}
result
}
// 正确示例：使用 Rust 惯用法
fn process_items(items: Vec<i32>) -> Vec<i32> {
items.into_iter()
.filter(|x| x % 2 == 0)
.map(|x| x * 2)
.collect()
}
// 更好的示例：使用泛型和特征
fn process_items<I>(items: I) -> Vec<i32>
where
I: IntoIterator<Item = i32>
{
items.into_iter()
.filter(|x| x % 2 == 0)
.map(|x| x * 2)
.collect()
}
总结
要写好 Rust 代码，需要注意以下几点：
深入理解并尊重所有权系统 合理使用借用而不是克隆 优雅地处理错误情况 善用迭代器和函数式编程特性 保持代码简洁，让编译器帮助你推断类型和生命周期 在适当的场景使用 unsafe 代码 采用合适的错误处理策略 充分利用异步编程生态系统 基于性能分析进行优化 遵循 Rust 的惯用法编写代码
记住，写出好的 Rust 代码需要时间和练习，持续学习和实践是提高的关键。
参考文章
10 Things You're Doing Wrong in Rust：https://byteblog.medium.com/10-things-youre-doing-wrong-in-rust-and-how-to-fix-them-631399680db1 Rust 官方文档：https://www.rust-lang.org/learn Rust 异步编程：https://rust-lang.github.io/async-book/ Rust 设计模式：https://rust-unofficial.github.io/patterns/
书籍推荐
各位 Rust 爱好者，今天为大家介绍一本《Programming Rust: Fast, Safe Systems Development》(第二版) 是由 Jim Blandy、Jason Orendorff 和 Leonora Tindall 合著的 Rust 编程指南。本书深入探讨了 Rust 语言在系统编程中的应用，着重介绍如何利用 Rust 的独特特性来平衡性能和安全性。书中涵盖了 Rust 的基础数据类型、所有权和借用概念、特征和泛型、并发编程、闭包、迭代器以及异步编程等核心内容。这本更新版基于 Rust 2021 版本，为系统程序员提供了全面而实用的 Rust 编程指导。
