Rust中DirectoryView去重文件并同步删除磁盘文件的优化方案

我定义了如下结构体：

struct FileView{
 name : String
 path : String
 //maybe other stuff
}
struct DirectoryView{
 files : Vec<FileView>
 //maybe other stuff
}

我希望在DirectoryView的impl中编写一个函数，找出按name字段重复的项，执行文件系统相关操作删除其中一个路径对应的磁盘文件，同时更新DirectoryView以移除重复项。

由于共享引用移出限制、同一数据多可变引用约束，以及dedup函数无法对被清除的重复项执行额外操作，实现起来颇具难度。目前我写出的最优实现如下：

fn purge_duplicates(&mut self) {
        self.files.sort_by(|a, b| a.name.cmp(&b.name));
        let mut prev_name = "rumplestilskin";
        let mut prev_path = "rumplestilskin";
        self.files.iter_mut().for_each(|file| {
            if file.name == prev_name {
                file.name = "DELETE_ME".to_owned();
                if file.path != prev_path {
                    std::fs::remove_file(&file.path).unwrap();
                }
            } else {
                prev_name = &file.name;
                prev_path = &file.path;
            }
        });
        self.files.retain(|file| file.name != "DELETE_ME");
    }

我并不满意这个实现——魔法字符串"rumplestilskin"和"DELETE_ME"、多轮遍历都显得十分繁琐。我想到的其他方案也不尽人意：

• 为FileView派生Clone trait，使用window方法生成新的Vec<FileView>并赋值给self.files，但这种方式不够简洁且仅适用于可克隆类型。
• 标记需要移除的文件索引，然后反向遍历这些索引进行删除。
• 为FileView实现Drop trait，在视图销毁时删除磁盘文件，但这一操作风险极高，可能导致数据丢失。

请问是否有更优的实现方式？

额外问题：我希望能更好地确保仅当保留项的路径与待删除项不同时，才删除磁盘文件（即不想因同一文件被多次引用而误删唯一的实际文件）。

可以通过分组处理+原地过滤或双指针原地排序过滤的方式解决问题，既避免魔法字符串，又减少不必要的遍历，同时精准处理同一文件重复引用的场景。

方案一：分组处理（逻辑清晰，适合中小数据量） #

实现思路 #

1. 按name将所有FileView分组；
2. 每组保留第一个项作为基准，其余项判断路径是否与基准不同：
   • 路径不同则删除对应磁盘文件；
   • 路径相同则直接丢弃视图，避免误删同一文件；
3. 重新构建files列表，替代原有Vec。

具体代码 #

use std::collections::HashMap;

impl DirectoryView {
    fn purge_duplicates(&mut self) {
        // 按name分组，暂存所有FileView
        let mut groups: HashMap<&str, Vec<FileView>> = HashMap::new();
        for file in self.files.drain(..) {
            groups.entry(&file.name).or_default().push(file);
        }

        // 处理每组重复项
        for (_name, mut files) in groups {
            if files.len() <= 1 {
                self.files.push(files.pop().unwrap());
                continue;
            }

            // 保留第一个项作为基准
            let keep = files.remove(0);
            self.files.push(keep.clone());

            // 处理剩余重复项
            for file in files {
                if file.path != keep.path {
                    // 替换unwrap为错误处理，避免程序崩溃
                    if let Err(e) = std::fs::remove_file(&file.path) {
                        eprintln!("Failed to delete file {}: {}", file.path, e);
                    }
                }
                // 路径相同的重复引用直接丢弃，不删除文件
            }
        }
    }
}

优势 #

• 无魔法字符串，逻辑直观；
• 精准处理同一文件重复引用的场景；
• 错误处理更健壮，避免因删除失败导致程序崩溃。

方案二：双指针原地过滤（内存开销低，适合大数据量） #

实现思路 #

1. 先按name排序；
2. 使用双指针在原Vec上原地过滤：
   • 写指针记录保留项的位置；
   • 读指针遍历所有项，遇到重复项则判断路径是否与保留项不同，决定是否删除文件；
   • 非重复项则移动到写指针位置，更新基准路径；
3. 截断Vec移除所有重复项。

具体代码 #

impl DirectoryView {
    fn purge_duplicates(&mut self) {
        let len = self.files.len();
        if len <= 1 {
            return;
        }

        // 按name排序
        self.files.sort_by_key(|f| f.name.clone());

        let mut write_idx = 1;
        let mut keep_path = &self.files[0].path;

        for read_idx in 1..len {
            let current = &mut self.files[read_idx];
            if current.name == self.files[write_idx - 1].name {
                // 重复项：路径不同则删除文件
                if current.path != keep_path {
                    if let Err(e) = std::fs::remove_file(&current.path) {
                        eprintln!("Failed to delete file {}: {}", current.path, e);
                    }
                }
            } else {
                // 非重复项：移动到写指针位置，更新基准
                self.files.swap(write_idx, read_idx);
                keep_path = &self.files[write_idx].path;
                write_idx += 1;
            }
        }

        // 截断Vec，移除重复项
        self.files.truncate(write_idx);
    }
}

优势 #

• 无需额外内存，原地操作性能更高；
• 仅一次排序+一次遍历，总操作次数更少；
• 同样能精准避免误删同一文件的重复引用。

内容的提问来源于stack exchange，提问作者Edward Peters