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<String, String> = {
        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<RefCell<u32>>,
}

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::<i32>().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<T>

，它提供了引用计数的指针类型

Rc<T>

，用于在多个位置共享数据。

Rc<T>

允许多个引用指向同一数据，但不能提供可变引用。通过增加和减少引用计数，当最后一个

Rc<T>

被丢弃时，共享数据会被自动释放。

Rc<T>

的常用方法包括：

clone：克隆一个 Rc<T>，增加引用计数。
strong_count：返回当前 Rc<T> 的强引用计数。
weak_count：返回当前 Rc<T> 的弱引用计数。
downgrade：将 Rc<T> 转换成 Weak<T>，创建一个弱引用。

RefCell

的全名是

std::cell::RefCell<T>

，它提供了在运行时跟踪借用规则的机制，允许在不可变引用的同时允许可变的内部修改。

RefCell<T>

在编译时不进行借用检查，而是在运行时进行检查。如果违反了借用规则（如多个可变引用同时存在），会导致运行时的 panic。

RefCell<T>

的常用方法包括：

borrow：返回一个不可变引用 Ref<T>。
borrow_mut：返回一个可变引用 RefMut<T>。
try_borrow：返回一个 Result<Ref<T>, BorrowError>，表示尝试获取不可变引用是否成功。
try_borrow_mut：返回一个 Result<RefMut<T>, BorrowMutError>，表示尝试获取可变引用是否成功。

需要注意的是，

RefCell<T>

只能用于非多线程环境。在多个线程中共享可变状态时，应使用

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<T> 可以增加引用计数
    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<RefCell<Data>>

创建了一个共享可变的

Data

结构体。然后克隆了

Rc

来创建多个引用，分别用于修改数据和读取数据。通过

borrow_mut

获取可变引用，并使用

borrow

获取不可变引用，可以在运行时动态跟踪借用规则，确保数据的安全共享和修改。

Rust 编程小技巧摘选(4)

Rust 编程小技巧(4)

使用 std::fs 模块

使用 lazy_static 宏

使用 Rc 和 RefCell

使用 Arc 和 Mutex

避免使用 unwrap()

避免不必要的复制

避免不必要的内存分配

编写测试和基准测试

附：

发表评论

“Rust 编程小技巧摘选(4)”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航