Rust模糊搜索插件库nucleo使用指南

概述

nucleo是一个高性能的Rust模糊搜索库，专注于提供快速、灵活的文本搜索与匹配功能。它特别适合需要实时模糊搜索的应用场景，如代码编辑器、文件搜索工具或任何需要高效文本匹配的应用程序。

主要特性

• 高性能模糊匹配算法
• Unicode支持
• 可配置的匹配策略
• 多线程支持
• 低内存占用

安装

在Cargo.toml中添加依赖：

[dependencies]
nucleo = "0.1"  # 请检查最新版本

基本使用方法

简单模糊搜索

use nucleo::Matcher;

fn main() {
    let mut matcher = Matcher::new(nucleo::Config::DEFAULT);
    
    let pattern = "rs";
    let candidates = vec!["Rust", "JavaScript", "TypeScript", "Python"];
    
    for candidate in candidates {
        let score = matcher.fuzzy_match(candidate, pattern);
        if score.is_some() {
            println!("Match found: {} (score: {:?})", candidate, score);
        }
    }
}

更复杂的匹配配置

use nucleo::{Matcher, Config, Utf32Str};

fn main() {
    let config = Config {
        case_sensitive: false,  // 不区分大小写
        normalize: true,        // 标准化Unicode字符
        ..Config::DEFAULT
    };
    
    let mut matcher = Matcher::new(config);
    let pattern = "núcleo";
    let candidate = "NUCLEO";
    
    let score = matcher.fuzzy_match(candidate, pattern);
    println!("Match score: {:?}", score);
}

多线程搜索

use nucleo::{Matcher, Config, Utf32Str};
use rayon::prelude::*;

fn main() {
    let config = Config::DEFAULT;
    let matcher = Matcher::new(config);
    
    let pattern = "rust";
    let candidates = vec![
        "Rust Programming Language",
        "JavaScript: The Good Parts",
        "Programming Rust",
        "Effective TypeScript"
    ];
    
    let results: Vec<_> = candidates
        .par_iter()
        .filter_map(|candidate| {
            matcher.fuzzy_match(candidate, pattern)
                .map(|score| (candidate, score))
        })
        .collect();
    
    for (candidate, score) in results {
        println!("Match: {} (score: {})", candidate, score);
    }
}

高级用法

自定义匹配权重

use nucleo::{Matcher, Config, Utf32Str};

fn main() {
    let config = Config {
        bonus_consecutive: 5,   // 连续匹配加分
        bonus_word_start: 10,   // 单词开头匹配加分
        ..Config::DEFAULT
    };
    
    let mut matcher = Matcher::new(config);
    let pattern = "mod";
    let candidates = vec!["module.rs", "models.rs", "mod.rs"];
    
    for candidate in candidates {
        if let Some(score) = matcher.fuzzy_match(candidate, pattern) {
            println!("{} matches with score {}", candidate, score);
        }
    }
}

处理大文本

use nucleo::{Matcher, Config, Utf32Str};

fn main() {
    let mut matcher = Matcher::new(Config::DEFAULT);
    let pattern = "error";
    
    let large_text = "This is a large text containing multiple words. \
                     An error occurred while processing the request. \
                     The error code is 404.";
    
    // 分割文本为单词
    let words: Vec<&str> = large_text.split_whitespace().collect();
    
    for word in words {
        if let Some(score) = matcher.fuzzy_match(word, pattern) {
            println!("Matched word: {} (score: {})", word, score);
        }
    }
}

完整示例

下面是一个结合了多种功能的完整示例：

use nucleo::{Matcher, Config, Utf32Str};
use rayon::prelude::*;

fn main() {
    // 配置匹配器
    let config = Config {
        case_sensitive: false,  // 不区分大小写
        normalize: true,        // 标准化Unicode
        bonus_consecutive: 5,   // 连续匹配加分
        bonus_word_start: 10,   // 单词开头匹配加分
        ..Config::DEFAULT
    };
    
    // 创建Matcher实例
    let matcher = Matcher::new(config);
    
    // 搜索模式
    let pattern = "rust";
    
    // 候选文本集合
    let candidates = vec![
        "The Rust Programming Language",
        "Learning Rust",
        "Rust in Action",
        "Programming Rust: Fast, Safe Systems Development",
        "Beginning Rust: From Novice to Professional",
        "Rust for Rustaceans",
        "The Rust Programming Language (Covers Rust 2018)",
        "Rust Cookbook",
        "Rust in Practice",
        "Zero To Production In Rust"
    ];
    
    // 使用多线程进行模糊匹配
    let results: Vec<_> = candidates
        .par_iter()
        .filter_map(|candidate| {
            matcher.fuzzy_match(candidate, pattern)
                .map(|score| (candidate, score))
        })
        .collect();
    
    // 按分数降序排序结果
    let mut sorted_results = results;
    sorted_results.sort_by(|a, b| b.1.cmp(&a.1));
    
    // 输出匹配结果
    println!("匹配结果(按相关性排序):");
    for (i, (candidate, score)) in sorted_results.iter().enumerate() {
        println!("{}. {} (分数: {})", i + 1, candidate, score);
    }
    
    // 处理大文本示例
    println!("\n大文本搜索示例:");
    let large_text = "Rust is a multi-paradigm, general-purpose programming language. \
                     Rust emphasizes performance, type safety, and concurrency. \
                     Rust enforces memory safety—that is, that all references point to valid memory—\
                     without requiring the use of a garbage collector or reference counting. \
                     Rust is popular for systems programming but also offers high-level features.";
    
    let words: Vec<&str> = large_text.split_whitespace().collect();
    
    for word in words {
        if let Some(score) = matcher.fuzzy_match(word, pattern) {
            println!("匹配词: {} (分数: {})", word, score);
        }
    }
}

性能提示

1. 重用Matcher实例以避免重复分配内存
2. 对于大量数据，考虑使用多线程处理
3. 根据实际需求调整Config参数以获得最佳性能

nucleo库提供了高度可配置的模糊搜索功能，可以根据具体应用场景调整匹配策略和权重设置。