Rust字符串模糊匹配库rapidfuzz的使用

RapidFuzz是一个通用的字符串匹配库，提供Rust、C++和Python实现。

主要特性

• 多样化的字符串度量：提供多种字符串度量方法，从基于编辑距离的Levenshtein距离到更精细相似度评估的Jaro-Winkler相似度
• 性能优化：库设计时考虑了性能，每个实现都经过精心设计以确保最佳性能，适合分析大型数据集
• 易用性：API设计简单易用，同时仍为优化实现留有空间

安装

安装非常简单：

cargo add rapidfuzz

使用示例

以下是使用Levenshtein距离的示例。其他度量方法可以在fuzz和distance模块中找到。

use rapidfuzz::distance::levenshtein;

// 使用Levenshtein距离进行简单比较
assert_eq!(
    3,
    levenshtein::distance("kitten".chars(), "sitting".chars())
);

// 如果确定输入字符串仅包含ASCII字符，通常对字节操作更快
assert_eq!(
    3,
    levenshtein::distance("kitten".bytes(), "sitting".bytes())
);

// 可以提供score_cutoff值来过滤掉距离比score_cutoff更差的字符串
assert_eq!(
    None,
    levenshtein::distance_with_args(
        "kitten".chars(),
        "sitting".chars(),
        &levenshtein::Args::default().score_cutoff(2)
    )
);

// 可以提供score_hint告诉实现预期的分数
// 这可以用来在内部选择更高效的实现，但当距离实际上比score_hint更差时可能会导致性能下降
assert_eq!(
    3,
    levenshtein::distance_with_args(
        "kitten".chars(),
        "sitting".chars(),
        &levenshtein::Args::default().score_hint(2)
    )
);

// 当比较单个字符串与多个字符串时，可以使用提供的`BatchComparators`
// 这些可以缓存部分计算结果，提供显著的加速
let scorer = levenshtein::BatchComparator::new("kitten".chars());
assert_eq!(3, scorer.distance("sitting".chars()));
assert_eq!(0, scorer.distance("kitten".chars()));

完整示例代码

use rapidfuzz::distance::levenshtein;

fn main() {
    // 基本字符串比较
    let distance = levenshtein::distance("rust".chars(), "rusty".chars());
    println!("Distance between 'rust' and 'rusty': {}", distance); // 输出: 1

    // 使用字节比较(ASCII字符串)
    let byte_distance = levenshtein::distance("rust".bytes(), "Rust".bytes());
    println!("Distance between 'rust' and 'Rust' (bytes): {}", byte_distance); // 输出: 1

    // 使用score_cutoff过滤结果
    let filtered_distance = levenshtein::distance_with_args(
        "hello".chars(),
        "world".chars(),
        &levenshtein::Args::default().score_cutoff(3)
    );
    println!("Filtered distance: {:?}", filtered_distance); // 输出: None

    // 批量比较器
    let names = vec!["Robert", "Rupert", "Rubin", "Robin"];
    let scorer = levenshtein::BatchComparator::new("Rust".chars());
    
    for name in names {
        let dist = scorer.distance(name.chars());
        println!("Distance between 'Rust' and '{}': {}", name, dist);
    }
    // 输出:
    // Distance between 'Rust' and 'Robert': 4
    // Distance between 'Rust' and 'Rupert': 3
    // Distance between 'Rust' and 'Rubin': 3
    // Distance between 'Rust' and 'Robin': 3
}

扩展示例：使用多种字符串度量方法

use rapidfuzz::{distance::levenshtein, fuzz::ratio};

fn main() {
    // 1. 使用Levenshtein距离
    let lev_dist = levenshtein::distance("book".chars(), "back".chars());
    println!("Levenshtein距离: {}", lev_dist); // 输出: 2

    // 2. 使用比率相似度
    let similarity = ratio("hello world".chars(), "hello word".chars());
    println!("相似度比率: {}", similarity); // 输出: 95

    // 3. 带权重的比较
    let weighted_dist = levenshtein::distance_with_args(
        "color".chars(),
        "colour".chars(),
        &levenshtein::Args::default()
            .weights(1, 1, 2) // 插入、删除、替换的权重
    );
    println!("带权重的距离: {}", weighted_dist); // 输出: 1

    // 4. 批量处理多个字符串
    let targets = ["apple", "aple", "appl", "peach", "peal"];
    let query = "apple";
    let scorer = levenshtein::BatchComparator::new(query.chars());
    
    println!("与'{}'的Levenshtein距离:", query);
    for target in targets {
        let dist = scorer.distance(target.chars());
        println!("- {}: {}", target, dist);
    }
    // 输出:
    // - apple: 0
    // - aple: 1
    // - appl: 1
    // - peach: 3
    // - peal: 3
}

许可证

根据Apache许可证2.0版或MIT许可证授权使用。除非您明确声明，否则您有意提交的任何贡献都应按上述方式双重许可，不附加任何额外条款或条件。