15、Rust 编程：文本提取与 grep 功能实现

Rust 编程：文本提取与 grep 功能实现

1. 文本提取功能概述

在 Rust 编程中，我们常常需要从输入文本中提取特定的字符、字节或字段。为了实现这些功能，我们需要完成几个关键步骤，包括创建配置对象、打开文件、提取字符或字节，以及解析分隔文本文件。

1.1 创建配置对象

首先，我们要确定创建哪种 Extract 变体。代码如下：

let extract = if let Some(field_pos) = fields {
    Fields(field_pos)
} else if let Some(byte_pos) = bytes {
    Bytes(byte_pos)
} else if let Some(char_pos) = chars {
    Chars(char_pos)
} else {
    return Err(From::from("Must have --fields, --bytes, or --chars"));
};

Ok(Config {
    files: matches.values_of_lossy("files").unwrap(),
    delimiter: delim_bytes[0],
    extract,
})

这个代码块根据输入的 fields 、 bytes 或 chars 来确定 extract 的类型。如果都没有提供，则返回错误。

1.2 打开文件

我们使用 open 函数来打开文件，该函数可以处理标准输入和普通文件：

fn open(filename: &str) -> MyResult<Box<dyn BufRead>> {
    match filename {
        "-" => Ok(Box::new(BufReader::new(io::stdin()))),
        _ => Ok(Box::new(BufReader::new(File::open(filename)?))),
    }
}

然后， run 函数可以处理多个文件，包括错误处理：

pub fn run(config: Config) -> MyResult<()> {
    for filename in &config.files {
        match open(filename) {
            Err(err) => eprintln!("{}: {}", filename, err),
            Ok(_file) => println!("Opened {}", filename),
        }
    }
    Ok(())
}

1.3 提取字符或字节

提取字符

我们编写了 extract_chars 函数来提取指定位置的字符：

fn extract_chars(line: &str, char_pos: &[usize]) -> String {
    let chars: Vec<_> = line.chars().collect();
    char_pos.iter().filter_map(|i| chars.get(*i)).collect()
}

这里使用了 Iterator::filter_map 来选择有效的字符位置并收集成新字符串。

以下是 extract_chars 函数的测试用例：

#[test]
fn test_extract_chars() {
    assert_eq!(extract_chars("", &[0]), "".to_string());
    assert_eq!(extract_chars("ábc", &[0]), "á".to_string());
    assert_eq!(extract_chars("ábc", &[0, 2]), "ác".to_string());
    assert_eq!(extract_chars("ábc", &[0, 1, 2]), "ábc".to_string());
    assert_eq!(extract_chars("ábc", &[2, 1]), "cb".to_string());
    assert_eq!(extract_chars("ábc", &[0, 1, 4]), "áb".to_string());
}

提取字节

extract_bytes 函数用于提取指定位置的字节：

fn extract_bytes(line: &str, byte_pos: &[usize]) -> String {
    let bytes = line.as_bytes();
    let selected: Vec<u8> = byte_pos
       .iter()
       .filter_map(|i| bytes.get(*i))
       .cloned()
       .collect();
    String::from_utf8_lossy(&selected).into_owned()
}

这里需要注意字节的克隆，以避免类型不匹配的错误。

以下是 extract_bytes 函数的测试用例：

fn test_extract_bytes() {
    assert_eq!(extract_bytes("ábc", &[0]), "�".to_string());
    assert_eq!(extract_bytes("ábc", &[0, 1]), "á".to_string());
    assert_eq!(extract_bytes("ábc", &[0, 1, 2]), "áb".to_string());
    assert_eq!(extract_bytes("ábc", &[0, 1, 2, 3]), "ábc".to_string());
    assert_eq!(extract_bytes("ábc", &[3, 2]), "cb".to_string());
    assert_eq!(extract_bytes("ábc", &[0, 1, 5]), "á".to_string());
}

1.4 解析分隔文本文件

为了通过最终测试，我们需要解析分隔文本文件。可以使用 csv 模块来完成这个任务。以下是一个示例代码：

use csv::StringRecord;
use std::fs::File;

fn main() -> std::io::Result<()> {
    let mut reader = csv::ReaderBuilder::new()
       .delimiter(b',')
       .from_reader(File::open("books.csv")?);
    fmt(reader.headers()?);
    for record in reader.records() {
        fmt(&record?);
    }
    Ok(())
}

fn fmt(rec: &StringRecord) {
    println!(
        "{}",
        rec.into_iter()
           .map(|v| format!("{:20}", v))
           .collect::<Vec<String>>()
           .join("")
    )
}

这个代码使用 csv::ReaderBuilder 来解析 books.csv 文件，并格式化输出。

1.5 提取字段

我们还编写了 extract_fields 函数来从 StringRecord 中提取指定位置的字段：

fn extract_fields(record: &StringRecord, field_pos: &[usize]) -> Vec<String> {
    field_pos
       .iter()
       .filter_map(|i| record.get(*i))
       .map(|v| v.to_string())
       .collect()
}

以下是 extract_fields 函数的测试用例：

#[test]
fn test_extract_fields() {
    let rec = StringRecord::from(vec!["Captain", "Sham", "12345"]);
    assert_eq!(extract_fields(&rec, &[0]), &["Captain"]);
    assert_eq!(extract_fields(&rec, &[1]), &["Sham"]);
    assert_eq!(extract_fields(&rec, &[0, 2]), &["Captain", "12345"]);
    assert_eq!(extract_fields(&rec, &[0, 3]), &["Captain"]);
    assert_eq!(extract_fields(&rec, &[1, 0]), &["Sham", "Captain"]);
}

1.6 最终的 run 函数

pub fn run(config: Config) -> MyResult<()> {
    for filename in &config.files {
        match open(filename) {
            Err(err) => eprintln!("{}: {}", filename, err),
            Ok(file) => match &config.extract {
                Fields(field_pos) => {
                    let mut reader = ReaderBuilder::new()
                       .delimiter(config.delimiter)
                       .has_headers(false)
                       .from_reader(file);
                    let mut wtr = WriterBuilder::new()
                       .delimiter(config.delimiter)
                       .from_writer(io::stdout());
                    for record in reader.records() {
                        let record = record?;
                        wtr.write_record(extract_fields(
                            &record, field_pos,
                        ))?;
                    }
                }
                Bytes(byte_pos) => {
                    for line in file.lines() {
                        println!("{}", extract_bytes(line?, &byte_pos));
                    }
                }
                Chars(char_pos) => {
                    for line in file.lines() {
                        println!("{}", extract_chars(line?, &char_pos));
                    }
                }
            },
        }
    }
    Ok(())
}

这个函数根据配置对象的 extract 类型，选择不同的提取方式并输出结果。

1.7 总结

通过以上步骤，我们实现了从输入文本中提取字符、字节和字段的功能。在实现过程中，我们学习了如何使用 Rust 的一些特性，如 Iterator::filter_map 、 Vec::get 、 String::from_utf8_lossy 等。同时，我们还使用了 csv 模块来解析分隔文本文件。

以下是一个简单的流程图，展示了整个文本提取的流程：

graph TD;
    A[开始] --> B[创建配置对象];
    B --> C[打开文件];
    C --> D{选择提取方式};
    D -- 字符 --> E[提取字符];
    D -- 字节 --> F[提取字节];
    D -- 字段 --> G[解析分隔文件并提取字段];
    E --> H[输出结果];
    F --> H;
    G --> H;
    H --> I[结束];

2. grep 功能概述

2.1 grep 功能简介

grep 程序用于查找输入中匹配给定正则表达式的行。默认情况下，输入可以来自标准输入，也可以提供一个或多个文件或目录名（如果使用递归选项）。正常输出是匹配给定模式的行，但也可以反转匹配以查找不匹配的行，还可以指示 grep 打印匹配行的数量而不是行本身。模式匹配通常是区分大小写的，但可以使用选项进行不区分大小写的匹配。

2.2 grep 的工作原理

BSD grep

BSD grep 命令接受许多不同的选项，其手册页显示了详细信息：
| 名称 | 描述 |
| ---- | ---- |
| grep | 用于简单模式和基本正则表达式（BREs） |
| egrep | 可以处理扩展正则表达式（EREs） |
| fgrep | 比 grep 和 egrep 更快，但只能处理固定模式（即不解释正则表达式） |

GNU grep

GNU grep 的语法和功能与 BSD grep 类似：

grep [OPTIONS] PATTERN [FILE...]
grep [OPTIONS] [-e PATTERN | -f FILE] [FILE...]

grep 搜索指定的输入文件（如果没有指定文件，则从标准输入读取），查找包含与给定模式匹配的行，并默认打印匹配的行。

2.3 grep 示例

测试文件

我们使用 09_grepr/tests/inputs 目录下的文件进行测试：

$ cd 09_grepr/tests/inputs
$ wc -l *
       9 bustle.txt
       0 empty.txt
       1 fox.txt
       9 nobody.txt
      19 total

空正则表达式匹配

一个空的正则表达式将匹配所有输入行：

$ grep "" fox.txt
The quick brown fox jumps over the lazy dog.

区分大小写匹配

在 nobody.txt 文件中搜索 Nobody ：

$ grep Nobody nobody.txt
I'm Nobody! Who are you?
Are you—Nobody—too?

搜索小写的 nobody 则没有匹配结果：

$ grep nobody nobody.txt

使用 -i|--ignore-case 选项进行不区分大小写的匹配：

$ grep -i nobody nobody.txt
I'm Nobody! Who are you?
Are you—Nobody—too?

反转匹配

使用 -v|--invert-match 选项查找不匹配的行：

$ grep -v Nobody nobody.txt
Then there's a pair of us!
Don't tell! they'd advertise—you know!
How dreary—to be—Somebody!
How public—like a Frog—
To tell one's name—the livelong June—
To an admiring Bog!

统计匹配行数

使用 -c|--count 选项统计匹配行的数量：

$ grep -c Nobody nobody.txt
2

结合 -v 和 -c 统计不匹配行的数量：

$ grep -vc Nobody nobody.txt
7

多文件搜索

搜索多个文件时，输出会包含文件名：

$ grep The *.txt
bustle.txt:The bustle in a house
bustle.txt:The morning after death
bustle.txt:The sweeping up the heart,
fox.txt:The quick brown fox jumps over the lazy dog.
nobody.txt:Then there's a pair of us!

统计多个文件的匹配行数时也会包含文件名：

$ grep -c The *.txt
bustle.txt:3
empty.txt:0
fox.txt:1
nobody.txt:1

2.4 总结

通过这些示例，我们了解了 grep 的基本用法，包括区分大小写匹配、不区分大小写匹配、反转匹配和统计匹配行数等。在实际应用中， grep 是一个非常强大的文本搜索工具，可以帮助我们快速定位和筛选所需的信息。

以下是一个简单的流程图，展示了 grep 的工作流程：

graph TD;
    A[开始] --> B[指定模式和文件];
    B --> C{选择匹配选项};
    C -- 区分大小写 --> D[进行区分大小写匹配];
    C -- 不区分大小写 --> E[进行不区分大小写匹配];
    C -- 反转匹配 --> F[查找不匹配的行];
    C -- 统计行数 --> G[统计匹配或不匹配的行数];
    D --> H[输出匹配结果];
    E --> H;
    F --> H;
    G --> H;
    H --> I[结束];

在学习和使用 grep 时，我们还可以进一步探索其更多的选项和用法，以满足不同的需求。同时，我们也可以结合其他命令和工具，实现更复杂的文本处理任务。

3. 文本提取与 grep 功能的应用与拓展

3.1 文本提取功能的应用场景

文本提取功能在很多实际场景中都有广泛的应用，以下是一些常见的例子：
- 数据清洗 ：在处理大量数据时，可能需要从原始数据中提取特定的字段或信息，去除无用的数据。例如，从日志文件中提取关键的错误信息或用户操作记录。
- 信息抽取 ：从网页、文档等文本中提取特定的信息，如从新闻文章中提取事件的时间、地点、人物等信息。
- 数据转换 ：将一种格式的文本数据转换为另一种格式，例如将 CSV 文件中的某些字段提取出来并转换为 JSON 格式。

3.2 grep 功能的拓展应用

除了基本的文本搜索功能， grep 还可以通过与其他命令结合使用，实现更强大的功能。以下是一些拓展应用的示例：

与 find 命令结合

find 命令用于查找文件，结合 grep 可以在指定目录下的所有文件中搜索特定的模式。例如，查找当前目录及其子目录下所有包含 “error” 关键字的文件：

find . -type f -exec grep -H "error" {} +

这个命令首先使用 find 找到所有普通文件，然后对每个文件执行 grep 命令进行搜索，并使用 -H 选项显示文件名。

与 sort 和 uniq 命令结合

sort 命令用于对文本进行排序， uniq 命令用于去除重复的行。结合 grep 、 sort 和 uniq 可以统计文本中出现的特定模式的频率。例如，统计日志文件中不同错误类型的出现次数：

grep "error" log.txt | cut -d ':' -f 2 | sort | uniq -c

这个命令首先使用 grep 找到所有包含 “error” 的行，然后使用 cut 命令提取错误类型（假设错误类型在冒号后面），接着使用 sort 对错误类型进行排序，最后使用 uniq -c 统计每个错误类型的出现次数。

3.3 文本提取与 grep 功能的性能优化

在处理大量数据时，性能是一个重要的考虑因素。以下是一些性能优化的建议：

文本提取功能的优化

• 减少不必要的内存分配 ：在提取字符或字节时，尽量避免不必要的内存分配。例如，在 extract_chars 和 extract_bytes 函数中，使用 filter_map 直接处理数据，避免创建中间的向量。
• 并行处理 ：如果需要处理多个文件，可以考虑使用并行处理来提高效率。例如，使用 Rust 的 rayon 库来并行处理文件。

grep 功能的优化

• 使用更高效的正则表达式 ：尽量使用简单、高效的正则表达式，避免使用过于复杂的模式。例如，使用固定字符串匹配而不是正则表达式匹配可以提高性能。
• 缓存正则表达式 ：如果需要多次使用相同的正则表达式，可以将其缓存起来，避免重复编译。

3.4 总结

文本提取和 grep 功能是非常实用的工具，可以帮助我们处理和分析大量的文本数据。通过了解它们的基本原理和用法，并结合实际应用场景进行拓展和优化，我们可以更高效地完成各种文本处理任务。

以下是一个简单的流程图，展示了文本提取和 grep 功能在实际应用中的流程：

graph TD;
    A[开始] --> B{选择任务};
    B -- 文本提取 --> C[确定提取方式];
    B -- grep 搜索 --> D[指定模式和文件];
    C --> E[打开文件];
    D --> E;
    E --> F{选择操作};
    F -- 提取字符 --> G[提取字符];
    F -- 提取字节 --> H[提取字节];
    F -- 提取字段 --> I[解析分隔文件并提取字段];
    F -- 搜索匹配行 --> J[进行匹配操作];
    G --> K[输出结果];
    H --> K;
    I --> K;
    J --> K;
    K --> L[结束];

4. 进一步学习与探索

4.1 Rust 语言的深入学习

Rust 是一种强大的系统编程语言，具有内存安全、高性能等特点。在学习文本提取和 grep 功能的过程中，我们已经接触到了 Rust 的一些基本特性，如正则表达式的使用、迭代器的操作等。为了进一步提高编程能力，可以深入学习 Rust 的其他特性，如所有权系统、并发编程、宏等。

4.2 正则表达式的高级用法

正则表达式是文本处理中非常重要的工具，除了基本的匹配功能，还有很多高级用法可以学习。例如，使用捕获组、回溯引用、零宽断言等功能可以实现更复杂的匹配和替换操作。

4.3 其他文本处理工具和库

除了 Rust 中的文本处理功能，还有很多其他的工具和库可以用于文本处理。例如，Python 中的 re 模块、 pandas 库，以及 Java 中的 java.util.regex 包等。学习这些工具和库可以拓宽我们的技术视野，提高文本处理的效率。

4.4 总结

通过学习文本提取和 grep 功能，我们掌握了一些基本的文本处理技巧。在未来的学习和工作中，我们可以进一步深入学习相关的知识和技术，不断提高自己的编程能力和解决问题的能力。同时，我们也可以将这些知识应用到实际项目中，为实际问题提供解决方案。

以下是一个简单的学习路径图，展示了进一步学习的方向：

graph LR;
    A[文本提取与 grep 基础] --> B[Rust 语言深入学习];
    A --> C[正则表达式高级用法];
    A --> D[其他文本处理工具和库];
    B --> E[更复杂的文本处理项目];
    C --> E;
    D --> E;

通过不断学习和实践，我们可以在文本处理领域取得更好的成果，为自己的职业生涯打下坚实的基础。