Rust 编程小技巧摘选(4)
Rust 编程小技巧(4)
使用 std::fs 模块
Rust 的 std::fs 模块提供了许多方便的函数，可以用于读写文件和目录。使用 std::fs 可以避免使用不安全的 C 函数，提高代码的可读性和可维护性。
use std::fs::File;
use std::io::prelude::*;
fn main() -> std::io::Result<()> {
let mut file = File::create("output.txt")?;
file.write_all(b"Hello, world!")?;
Ok(())
}使用 lazy_static 宏
lazy_static 宏可以用于定义全局静态变量，该变量的值只会在首次使用时计算。这可以避免不必要的计算和内存分配。
#[macro_use]
extern crate lazy_static;
use std::collections::HashMap;
lazy_static! {
static ref CONFIG: HashMap = {
let mut map = HashMap::new();
map.insert(String::from("name"), String::from("Alice"));
map.insert(String::from("age"), String::from("30"));
map
};
}
fn main() {
println!("{:?}", CONFIG);
} 使用 Rc 和 RefCell
Rc 和 RefCell 可以用于实现共享可变状态。Rc 允许多个所有者共享同一个值，而 RefCell 允许在运行时检查借用规则，从而允许在不可变引用的情况下修改值。
use std::cell::RefCell;
use std::rc::Rc;
#[derive(Debug)]
struct Person {
name: String,
age: Rc>,
}
impl Person {
fn new(name: String, age: u32) -> Self {
Self {
name,
age: Rc::new(RefCell::new(age)),
}
}
fn happy_birthday(&self) {
let mut age = self.age.borrow_mut();
*age += 1;
}
}
fn main() {
let alice = Person::new(String::from("Alice"), 30);
alice.happy_birthday();
println!("{:?}", alice);
} 使用 Arc 和 Mutex
Arc 和 Mutex 可以用于实现多线程共享状态。Arc 允许多个线程共享同一个值，而 Mutex允许在运行时检查数据竞争，从而允许多个线程访问共享状态的互斥性修改。
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let counter = Arc::clone(&counter);
let handle = thread::spawn(move || {
let mut num = counter.lock().unwrap();
*num += 1;
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Result: {}", *counter.lock().unwrap());
}避免使用 unwrap()
unwrap() 是一个方便的函数，可以在程序出错时快速失败，但是过多使用 unwrap() 会导致代码不安全和不稳定。
fn main() {
let number = "42".parse::().unwrap_or(0);
println!("Number: {}", number);
} 避免不必要的复制
在 Rust 中，复制大型结构体或向量是昂贵的操作。可以使用引用或指针来避免不必要的复制。
struct Person {
name: String,
age: u32,
}
fn print_person(person: &Person) {
println!("{} is {} years old", person.name, person.age);
}避免不必要的内存分配
在 Rust 中，动态内存分配是昂贵的操作，可以使用栈上分配或重用已经分配好的内存来避免不必要的分配。
fn concat_strings(str1: &str, str2: &str) -> String {
let mut result = String::with_capacity(str1.len() + str2.len());
result.push_str(str1);
result.push_str(str2);
result
}编写测试和基准测试
编写测试和基准测试可以帮助程序员检测和优化程序性能问题。
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_sum_numbers() {
let numbers = vec![1, 2, 3, 4, 5];
assert_eq!(sum_numbers(&numbers), 15);
}
#[bench]
fn bench_sum_numbers(b: &mut test::Bencher) {
let numbers = vec![1, 2, 3, 4, 5];
b.iter(|| sum_numbers(&numbers));
}
}附： Rc&RefCell
Rust 中的 Rc（引用计数）和 RefCell（可变内部可借用性）是两个常用的智能指针和内部可变性机制，它们通常结合使用，用于在运行时管理共享数据，并在需要时提供内部可变性。
Rc 的全名是 std::rc::Rc，它提供了引用计数的指针类型 Rc，用于在多个位置共享数据。Rc 允许多个引用指向同一数据，但不能提供可变引用。通过增加和减少引用计数，当最后一个 Rc 被丢弃时，共享数据会被自动释放。
Rc 的常用方法包括：
clone：克隆一个Rc，增加引用计数。strong_count：返回当前Rc的强引用计数。weak_count：返回当前Rc的弱引用计数。downgrade：将Rc转换成Weak，创建一个弱引用。
RefCell 的全名是 std::cell::RefCell，它提供了在运行时跟踪借用规则的机制，允许在不可变引用的同时允许可变的内部修改。 RefCell 在编译时不进行借用检查，而是在运行时进行检查。如果违反了借用规则（如多个可变引用同时存在），会导致运行时的 panic。
RefCell 的常用方法包括：
borrow：返回一个不可变引用Ref。borrow_mut：返回一个可变引用RefMut。try_borrow：返回一个Result，表示尝试获取不可变引用是否成功。try_borrow_mut：返回一个Result，表示尝试获取可变引用是否成功。
需要注意的是，RefCell 只能用于非多线程环境。在多个线程中共享可变状态时，应使用 Mutex 或 RwLock 等线程安全的同步机制。
下面是一个示例代码，演示了 Rc 和 RefCell 的用法：
use std::rc::Rc;
use std::cell::RefCell;
struct Data {
value: i32,
}
fn main() {
let data = Rc::new(RefCell::new(Data { value: 42 }));
// 克隆 Rc 可以增加引用计数
let data1 = data.clone();
let data2 = data.clone();
{
// 使用 borrow_mut 获取可变引用，并修改数据
let mut borrowed_data = data1.borrow_mut();
borrowed_data.value += 10;
}
{
// 使用 borrow 获取不可变引用，并读取数据
let borrowed_data = data2.borrow();
println!("Value: {}", borrowed_data.value);
}
}
这个示例中，使用 Rc 创建了一个共享可变的 Data 结构体。然后克隆了 Rc 来创建多个引用，分别用于修改数据和读取数据。通过 borrow_mut 获取可变引用，并使用 borrow 获取不可变引用，可以在运行时动态跟踪借用规则，确保数据的安全共享和修改。
相关阅读：
Rust 编程小技巧摘选(1)_Hann Yang的博客-CSDN博客
Rust 编程小技巧摘选(2)_Hann Yang的博客-CSDN博客
Rust 编程小技巧摘选(3)_Hann Yang的博客-CSDN博客