Rust数字验证库verhoeff的使用，verhoeff提供高效校验和算法用于数字错误检测与验证

Rust数字验证库verhoeff的使用，verhoeff提供高效校验和算法用于数字错误检测与验证

Verhoeff算法是一种用于数字校验和的实现算法。虽然不如Luhn算法常见(例如在信用卡号中使用)，但它确实有特定的应用场景，比如印度Aadhaar生物识别身份系统使用12位数字作为ID号码，其中最后一位就是Verhoeff校验和。

示例代码

以下是使用verhoeff库的基本示例：

use verhoeff::Verhoeff;
assert_eq!("12345".calculate_verhoeff_check_digit(), 1);
assert!(verhoeff::validate(&[1, 2, 3, 4, 5, 1]));
assert!(!"123456".validate_verhoeff_check_digit());

use verhoeff::VerhoeffMut;
let mut digits = vec![1, 2, 3, 4, 5];
digits.push_verhoeff_check_digit();
assert_eq!(digits, [1, 2, 3, 4, 5, 1]);

完整示例demo

// 引入verhoeff库
use verhoeff::{Verhoeff, VerhoeffMut};

fn main() {
    // 示例1: 计算校验数字
    let number = "12345";
    let check_digit = number.calculate_verhoeff_check_digit();
    println!("Number: {}, Check digit: {}", number, check_digit);  // 输出: Number: 12345, Check digit: 1
    
    // 示例2: 验证带有校验数字的完整号码
    let full_number = [1, 2, 3, 4, 5, 1];  // 123451
    let is_valid = verhoeff::validate(&full_number);
    println!("Is {} valid? {}", format!("{:?}", full_number), is_valid);  // 输出: Is [1, 2, 3, 4, 5, 1] valid? true
    
    // 示例3: 直接验证字符串形式的号码
    let invalid_number = "123456";
    let is_valid = invalid_number.validate_verhoeff_check_digit();
    println!("Is {} valid? {}", invalid_number, is_valid);  // 输出: Is 123456 valid? false
    
    // 示例4: 动态添加校验数字到向量
    let mut digits = vec![9, 8, 7, 6];  // 9876
    digits.push_verhoeff_check_digit();
    println!("Number with check digit: {:?}", digits);  // 输出: Number with check digit: [9, 8, 7, 6, 4]
}

Cargo.toml配置

标准使用方式：

[dependencies]
verhoeff = "1"

禁用std功能但保留alloc(不失去任何功能):

[dependencies]
verhoeff = { version = "1", default-features = false, features = ["alloc"] }

禁用std功能且不启用alloc(将失去VerhoeffMut对String和Vec<u8>的实现):

[dependencies]
verhoeff = { version = "1", default-features = false }

Verhoeff算法提供了一种高效的数字错误检测与验证方法，适用于需要高可靠性数字验证的场景。通过简单的API，开发者可以轻松计算校验数字并验证数字序列的有效性。


1 回复

Rust数字验证库verhoeff的使用

介绍

verhoeff是一个Rust实现的Verhoeff校验和算法库，用于数字错误检测与验证。Verhoeff算法是一种高效的校验和算法，能够检测所有单一数字错误以及大多数常见的数字排列错误。

该算法由荷兰数学家Jacobus Verhoeff在1969年提出，比简单的Luhn算法(如信用卡号校验)更强大，能检测更多类型的错误。

使用方法

添加依赖

首先在Cargo.toml中添加依赖：

[dependencies]
verhoeff = "0.2"

基本使用

use verhoeff::Verhoeff;

fn main() {
    // 验证数字串的有效性
    let valid_number = "2363";
    let invalid_number = "2364";
    
    println!("{} is valid: {}", valid_number, Verhoeff::validate(valid_number));
    println!("{} is valid: {}", invalid_number, Verhoeff::validate(invalid_number));
    
    // 为数字串生成校验位
    let number = "236";
    let check_digit = Verhoeff::generate_check_digit(number);
    println!("Check digit for {} is: {}", number, check_digit);
    
    // 生成带有校验位的完整数字
    let full_number = Verhoeff::generate(number);
    println!("Full number with check digit: {}", full_number);
}

处理大数字

use verhoeff::Verhoeff;

fn main() {
    // 处理大数字作为字符串
    let big_num = "12345678901234567890";
    let check_digit = Verhoeff::generate_check_digit(big_num);
    println!("Check digit for {} is: {}", big_num, check_digit);
    
    // 验证大数字
    let big_num_with_check = "123456789012345678902";
    println!("Is valid: {}", Verhoeff::validate(big_num_with_check));
}

处理数字向量

use verhoeff::Verhoeff;

fn main() {
    // 使用数字向量
    let digits = vec![1, 2, 3, 4];
    let check_digit = Verhoeff::generate_check_digit_from_digits(&digits);
    println!("Check digit for {:?} is: {}", digits, check_digit);
    
    // 验证数字向量
    let digits_with_check = vec![1, 2, 3, 4, 1];
    println!("Is valid: {}", Verhoeff::validate_digits(&digits_with_check));
}

完整示例

use verhoeff::Verhoeff;

fn main() {
    // 示例1：基本验证
    println!("=== 基本验证 ===");
    let numbers = ["2363", "2364", "123451"];
    for num in numbers.iter() {
        println!("{} 是否有效: {}", num, Verhoeff::validate(num));
    }

    // 示例2：生成校验位
    println!("\n=== 生成校验位 ===");
    let numbers_to_check = ["236", "12345", "987654321"];
    for num in numbers_to_check.iter() {
        let check_digit = Verhoeff::generate_check_digit(num);
        println!("数字 {} 的校验位是: {}", num, check_digit);
        
        let full_number = Verhoeff::generate(num);
        println!("完整数字(带校验位): {}", full_number);
    }

    // 示例3：处理大数字
    println!("\n=== 处理大数字 ===");
    let big_num = "12345678901234567890";
    let check_digit = Verhoeff::generate_check_digit(big_num);
    println!("大数字 {} 的校验位是: {}", big_num, check_digit);
    
    let verified = format!("{}{}", big_num, check_digit);
    println!("验证大数字 {}: {}", verified, Verhoeff::validate(&verified));

    // 示例4：处理数字向量
    println!("\n=== 处理数字向量 ===");
    let digit_vecs = [
        vec![1, 2, 3, 4],
        vec![9, 8, 7, 6, 5],
        vec![0, 1, 0, 1, 0, 1]
    ];
    
    for digits in digit_vecs.iter() {
        let check_digit = Verhoeff::generate_check_digit_from_digits(digits);
        println!("数字向量 {:?} 的校验位是: {}", digits, check_digit);
        
        let mut verified_digits = digits.clone();
        verified_digits.push(check_digit);
        println!("验证数字向量 {:?}: {}", verified_digits, 
            Verhoeff::validate_digits(&verified_digits));
    }
}

应用场景

  1. 身份证号码校验：防止输入错误
  2. 产品序列号验证：确保序列号有效
  3. 金融系统：账户号码校验
  4. 数据录入系统：减少人工输入错误

性能特点

  • 时间复杂度为O(n)，适用于长数字串
  • 轻量级实现，无额外依赖
  • 能检测所有单一数字错误和大多数排列错误

注意事项

  • 输入应为数字字符串或数字向量，包含非数字字符会导致错误
  • 算法不适用于字母或其他字符的校验
  • 空字符串或向量会被视为无效输入
回到顶部