Rust 笔记：Rust 语言中应用正则表达式

Rust 笔记 Rust 语言中应用正则表达式

---

作者：李俊才 （jcLee95）：https://blog.csdn.net/qq_28550263?spm=1001.2101.3001.5343
邮箱 ：[email protected]
本文地址：https://blog.csdn.net/qq_28550263/article/details/130876707

---

【介绍】：本文讲解 正则表达式相关概念，以及如何在 Rust 语言中使用正则表达式。

上一节：《 Rust 语言中的字符串 》 | 下一节：《 Rust 语言中哈希表（HashMap）及其使用 》

---

---

1. 概述

1.1 正则表达式 和 regex 模块

正则表达式用于描述各种复杂的字符串关系，使用正则表达式能够更加灵活便捷地处理字符串，它是使用单个字符串来描述、匹配一系列符合某个句法规则的字符串搜索模式。在 Rust 语言中，目前我们主要通过 regex 模块 来使用正则表达式。 regex 模块 是一个用于解析、编译和执行正则表达式的 Rust 库。

依据该模块自己的介绍，它的语法类似于 Perl 风格的正则表达式，但是缺少一些特性，比如环视和反向引用。作为交换，所有搜索都根据正则表达式和搜索文本的大小以线性时间执行。很多语法和实现都是受RE2的启发。你可以在 https://crates.io 的 regex 模块主页中查看器最新的发布信息：https://crates.io/crates/regex，或者直接进入该模块的 Github 开源仓库查看：https://github.com/rust-lang/regex。

1.2 在 Rust 项目中配置 regex 模块

现在我们准备一个新的 rust 项目，来讲解如何配置使用 regex 模块：

# 新建项目
cargo new use-regex

接着，进入该项目，并安装regex：

# 进入 use-regex 项目根目录
cd use-regex

# 安装 regex 模块
cargo add regex

Tip:
如果你的安装很慢，不妨参考博文 《Crate 国内源配置》 设置和使用 rust cargo 工具的国内源镜像进行安装。

安装成功可，可以看到项目的Cargo.toml配置文件新增了一个 regex 的依赖项：

2. 字符串规则描述符

>点击此处可以直接查询元字符表

2.1 定位符：描述字符的边界

符号	描述	说明
^	匹配一个字符串的起始字符	如果多行标志被设置为 true，那么也匹配换行符后紧跟的位置。
$	匹配一个字符串的结尾字符	如果多行标志被设置为 true，那么也匹配换行符前的位置。
\b	匹配一个单词的边界	-
\B	匹配非单词边界	相当于\b匹配的反集

例如从一篇博客的博文中，提取所有的标题：

use regex::Regex;

fn main() {
    let markdown_text = "# Header 1\n## Header 2\n### Header 3\n#### Header 4\n##### Header 5\n###### Header 6";
    let re = Regex::new(r"(?m)^(#{1,6})\s+(.+)$").unwrap();
    for cap in re.captures_iter(markdown_text) {
        let level = cap[1].len();
        let header = cap[2].trim();
        println!("标题等级：{}；文本：\"{}\"", level, header);
    }
}

其输出结果为：

标题等级：1；文本："Header 1"
标题等级：2；文本："Header 2"
标题等级：3；文本："Header 3"
标题等级：4；文本："Header 4"
标题等级：5；文本："Header 5"
标题等级：6；文本："Header 6"

2.2 限定符：描述重复匹配的次数

符号	描述	说明
?	匹配该限定符前的字符0或1次	等价于 {0,1}，如 colou?r 可以匹配colour和color
+	匹配该限定符前的字符1或多次	等价于 {1,}，如 hel+o可以匹配helo、hello、helllo、…
*	匹配该限定符前的字符0或多次	等价于 {0,}，如 hel*o可以匹配heo、helo、hello、helllo、…
{n}	匹配该限定符前的字符n次	如 hel{2}o只可以匹配hello
{n,}	匹配该限定符前的字符最少n次	如 hel{2,}o可以匹配hello、helllo、…
{n,m}	匹配该限定符前的字符最少n次，最多m次	如 hel{2,3}o只可以匹配hello 和 helllo

2.3 字符描述

符号	描述	说明
\d	匹配任意数字
\s	匹配任意空白符
\w	匹配任意字母、数字、下划线、汉字等
\D	匹配任意非数字
\S	匹配任意非空白符
\W	匹配除了字母、数字、下划线、汉字以外的字符
.	匹配除了换行符以外的任意字符

形式	描述	说明
[A-Z]	区间匹配，匹配字母表该区间所有大写字母	如[C-F]匹配字符C、D、E、F
[a-z]	区间匹配，匹配字母表该区间所有小写字母	如[c-f]匹配字符c、d、e、f
[0-9]	区间匹配，匹配该区间内的所有数字	如[3-6]匹配字符3、4、5、6
[ABCD]	列表匹配，匹配[]中列出的所有字母	如这里列出的A、B、C、D都会被匹配
[^ABCD]	列表排除，匹配除了[]中列出的字符外的所有字符	如这里列出的A、B、C、D都会被排除而匹配其它字符

例如，使用正则表达式提取文本中的数字和非数字分类返回：

use regex::Regex;
use std::collections::HashMap;

// 定义一个函数，接收一个字符串参数，返回一个哈希表
fn classify_text(text: &str) -> HashMap<&str, Vec<&str>> {
    // 定义一个正则表达式，匹配数字和非数字字符
    let re = Regex::new(r"(\d+)|(\D+)").unwrap();
    let mut map = HashMap::new();
    // 遍历匹配结果
    for cap in re.captures_iter(text) {
        // 获取匹配到的数字或非数字字符
        let value = cap.get(0).unwrap().as_str();
        // 根据匹配到的数字或非数字字符，将其加入到对应的向量中
        if cap.get(1).is_some() {
            map.entry("数字").or_insert(Vec::new()).push(value);
        } else {
            map.entry("非数字").or_insert(Vec::new()).push(value);
        }
    }
    map
}

fn main() {
    let text = "abc123def456";
    let result = classify_text(text);
    println!("{:?}", result);
}

运行项目：

cargo run

可以看到输出结果为：

{"非数字": ["abc", "def"], "数字": ["123", "456"]}

再如，匹配IPV4地址：

use regex::Regex;

fn main() {
    let re = Regex::new(r"[1-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[1-9]{1,3}").unwrap();
    let text = "这是一段用于演示匹配的文本。192.168.0.1 是一个合法的 IP 地址，然而 900.300.700.600 不是.";
    for cap in re.captures_iter(text) {
        println!("匹配到合法的IP地址: {}", &cap[0]);
    }
}

然后在你的项目目录下运行命令：

cargo run

可以从输出结果中看到文本中的前一个地址被提取出来了：

2.4 管道符：“或”匹配逻辑

管道符就是一根竖线：|，再正则表达式中标识”或“。由于匹配方向时从左向右进行的，假如有两个正则表达式A和B，那么使用 A|B 匹配字符串时，只要前一个样式完全匹配成功，那么后一个就不再匹配。

例如：

use regex::Regex;

fn main() {
    let re = Regex::new(r"hello|world").unwrap();
    let text = "hello world";
    for mat in re.find_iter(text) {
        println!("{}", mat.as_str());
    }
}

输出为：

hello
world

2.5 转义字符：将特殊符号标识为普通字符

在正则表达式中用于标识特殊含义的符号如.用于标识一个任意的非换行符字符，^标识起始字符，等等。但是我们希望匹配到这些字符本身也是经常遇到的情况，如IPV4地址使用.作为分割符。因此我们如果需要完整提取IPV4地址就需要表示.本身。由于直接使用点已经有了其它的含义，因此我们使用一个\号进行转义，即使用\.来表示点（.）。其它在正则中有特殊含义的符号也可以使用类似的方式。

2.6 分组

与数学计算中采用小括号()进行算式分组一样，正则模板也能够分组表达，目的是将某一部分正则模板作为一个整体表达，例如模板：

use regex::Regex;

fn main() {
    let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
    let text = "当前的日期是 2023-05-28";
    if let Some(captures) = re.captures(text) {
        println!("年: {}", captures.get(1).unwrap().as_str());
        println!("月: {}", captures.get(2).unwrap().as_str());
        println!("日: {}", captures.get(3).unwrap().as_str());
    }
}

运行项目：

cargo run

可以从输出结果中看到从文本中分别取出了年、月、日：

3. 创建正则表达式对象的方法

3.1 正则对象的字面量

Rust中的正则表达式字面量是由斜杠（/）包围的字符串。可以使用正则表达式的方法来匹配和搜索字符串。
例如，下面的代码将匹配所有以字母“a”开头的单词：

let re = Regex::new(r"\ba\w+").unwrap();

这个正则表达式使用了单词边界（\b）和一个或多个字母数字字符（\w+）来匹配以字母“a”开头的单词。

再比如使用正则表达式来替换字符串中的所有匹配项：

let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
let date_replaced = re.replace_all("Today's date is 2022-01-01", "$2/$3/$1");

这个正则表达式匹配日期格式“YYYY-MM-DD”，然后使用捕获组来重新排列日期格式为“MM/DD/YYYY”。

3.2 使用正则表达式字符串

例如：

let re = Regex::new("^\\d{3}-\\d{2}-\\d{4}$").unwrap();

3.3 使用正则表达式字符串和编译选项

例如：

let re = Regex::new_with_options("^\\d{3}-\\d{2}-\\d{4}$", RegexOptions::MULTILINE).unwrap();

3.4 使用正则表达式字符串和编译选项和错误处理

例如：

let re = match Regex::new_with_options("^\\d{3}-\\d{2}-\\d{4}$", RegexOptions::MULTILINE) {
    Ok(re) => re,
    Err(err) => panic!("Failed to create regex: {}", err),
};

4. 实现其它语言正则中匹配模式标志的功能

4.1 关于匹配模式

一些语言的正则表达式，如 JavaScript、Python 等等，可以使用一定的形式指定 匹配模式，比如 JavaScript 语言中的正则表达式可以在正则表达式字面量末尾附加以下模式符号，实现相关的匹配功能：

符号	描述	说明
g	全局匹配	找到所有的匹配，而不是在第一个匹配之后停止。
i	忽略大小写	如果u标志也被启用，使用Unicode大小写折叠。
m	多行匹配	将开始和结束字符(^ and $)视为在多行上工作。换句话说，匹配每一行的开头或结尾each line (由\n或者\r 分隔)，而不仅仅是整个输入字符串的开头或结尾。
s	点号匹配所有字符	允许. 去匹配新的行
u	unicode	将 pattern 视为 Unicode 码位序列。 参考 二进制字符串
y	sticky，粘性匹配	仅从目标字符串中此正则表达式的 lastIndex 属性指示的索引中匹配。不尝试从任何后续索引中匹配

从目前笔者所使用过的所有编程看，个人最喜欢 JavaScript 提供的正则表达式用法，因为它用起来最方便。很遗憾的是，Rust 正则表达式没有类似的匹配模式写法，不过部分功能的实现，可以借用也有很多语言在用的 内联匹配模式 语法，如 C#。可以参考 内联匹配模式，以及正则对象提供的各种方法来实现。

4.2 全局匹配

我们先看一段使用 JavaScript 正则表达式的代码，对比使用全局匹配与否有什么区别：

const str = 'hello1 world1, hello2 world2';
const reg1 = /hello/;
const reg2 = /hello/g;

console.log(str.match(reg1));
console.log(str.match(reg2)); 

其输出为：

[
  'hello',
  index: 0,
  input: 'hello1 world1, hello2 world2',
  groups: undefined
]
[ 'hello', 'hello' ]

可看出，不使用全局匹配g，只匹配到第一个符合条件的字符串。而使用全局匹配g，匹配到所有符合条件的字符串。

目前在 rust 这边会显得比较 笨拙 一些，需要使用不同的方式来实现。

以查找字符串为例。如果我们不希望全局匹配，只要求第一个匹配结果时，我们可以使用 find 方法。

例如下面这个例子中，我们提取第一个年月日：

let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
let text = "第一个年月日：2021-01-01, 第二个年月日：2022-02-01, 第三个年月日：2023-03-01";
let res = re.find(text).unwrap();

println!("{}",res.as_str())

其输出结果为：

2021-01-01

然而如果我们需要全局匹配，应该在返回一个包含所有满足要求结果的迭代器的方法中进行，然后对这个被返回的迭代器进行迭代遍历，以实现全局匹配效果。仍然以提取字符串为例，我们需要将上一个例子中的 find 方法改成 find_iter 方法。实现上一个例子的全局匹配提取字符串的代码改版如下：

let re = Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();
let text = "第一个年月日：2021-01-01, 第二个年月日：2022-02-01, 第三个年月日：2023-03-01";
for date in re.find_iter(text) {
    println!("{}", date.as_str());
}

其输出结果为：

2021-01-01
2022-02-01
2023-03-01

实际上，这个返回的迭代器就可以视为类似的数据容器使用，当然你也可以使用一个 vector 去容纳这些匹配的结果。不过总之而言相比于 JavaScript 中的那个例子，确实还是麻烦了不少。

4.3 忽略大小写匹配

大小写是针对英文字符的，这种匹配模式中，对于字母的大小写形式将不做区分，比如 i 和 I 都将被视作同一个字符。

以 JavaScript 为例，只需要在正则表达式末尾使用一个 i，表示忽略大小写：

console.log(/^h/i.test("Hello")); // true
console.log(/^h/i.test("hello")); // true

在 rust 中，我们目前使用只能 内联匹配模式 语法，给一个忽略指定字符大小写的例子：

let re = Regex::new(r"(?i)hello").unwrap();
let text1 = "Hello world!";
let text2 = "hello world!";
println!("{}", re.find(text1).unwrap().as_str());
println!("{}", re.find(text2).unwrap().as_str());

输出结果为：

Hello
hello

可以看到不论 h 字母大小写，都成功匹配提取出了hello。

4.4 多行匹配模式

在上一节已经接触了 内联匹配模式 的用法。这一节同样使用内联匹配模式给出一个 rust 多行匹配的例子：

let re = Regex::new(r"(?m)^\d+").unwrap();
let text = "1. First line\n2. Second line\n3. Third line";
for line in re.find_iter(text) {
    println!("{}", line.as_str());
}

输出为：

1
2
3

4.5 允许 . 去匹配新的行

这一节同样使用内联匹配模式给出一个 rust 中，允许 . 去匹配新的行模式的例子：

let re = Regex::new(r"(?s)hello.world").unwrap();
let text = "hello\nworld";
if let Some(matched) = re.find(text) {
    println!("已匹配：{}", matched.as_str());
}

输出为：

已匹配：hello
world

4.6 内联匹配的组合

你可以使用 i、s、m 的组合，实现同时使用多个匹配模式，如 (?is) 和 (?im)，可以参考 内联匹配模式 。

4.7 视为 Unicode 码位序列

这一节给出一个 Rust 中，将 pattern 视为 Unicode 码位序列的例子：

let re = Regex::new(r"\p{Han}+").unwrap();
let text = "你好，世界！";
if let Some(matched) = re.find(text) {
    println!("已匹配： {}", matched.as_str());
}

输出结果为：

已匹配： 你好

5. Regex API 解析

本节解析 Regex 的 API，内容主要为对 API 文档 https://docs.rs/regex/1.8.3/regex/struct.Regex.html 的中文翻译，对于部分 API，增加了一些实际使用的例子。

5.1 核心正则表达式方法

5.1.1 new 方法

描述

pub fn new（re： &str） -> Result<Regex， Error>

编译正则表达式。一旦编译，它可以重复使用，以搜索，分割或替换字符串中的文本。

如果给出了无效的表达式，则返回一个错误。

5.1.2 is_match 方法

描述

Pub FN is_match（&self， text： &str） -> bool

当且仅当给定的字符串中有匹配的正则表达式时，返回true。

如果您需要做的只是测试一个匹配，那么建议使用这种方法，因为底层的匹配引擎可以做更少的工作。

例子

测试某些文本是否包含至少一个正好为13个 Unicode 单词字符的单词：

let text = "I categorically deny having triskaidekaphobia.";
assert!(Regex::new(r"\b\w{13}\b").unwrap().is_match(text));

5.1.3 find 方法

描述

pub fn find<'t>（&self， text： &'t str） -> Option<Match<'t>>

返回文本中最左边第一个匹配的开始和结束字节范围。如果不存在匹配，则返回 None。

请注意，这应该只在您想要发现匹配的位置时使用。如果使用 is_match，测试匹配的存在会更快。

例子

用13个Unicode单词字符查找第一个单词的开始和结束位置:

let text = "I categorically deny having triskaidekaphobia.";
let mat = Regex::new(r"\b\w{13}\b").unwrap().find(text).unwrap();
assert_eq!(mat.start(), 2);
assert_eq!(mat.end(), 15);

5.4 find_iter 方法

描述

pub fn find_iter<'r, 't>(&'r self, text: &'t str) -> Matches<'r, 't>

为 text 中每个连续的非重叠匹配返回一个迭代器，返回相对于 text 的起始和结束字节索引。

例子

查找每个单词的开始和结束位置，每个单词正好有13个Unicode单词字符：

let text = "Retroactively relinquishing remunerations is reprehensible.";
for mat in Regex::new(r"\b\w{13}\b").unwrap().find_iter(text) {
    println!("{:?}", mat);
}

5.1.5 captures 方法

描述

pub fn captures<'t>(&self, text: &'t str) -> Option<Captures<'t>>

返回与文本中最左边的第一个匹配相对应的捕获组。捕获组 0 始终对应于整个匹配。如果找不到匹配，则不返回任何内容。

如果您需要访问捕获组匹配的位置，您应该只使用捕获。否则，查找会更快地发现整个匹配的位置。

例子

假设您有一些带有电影名称及其上映年份的文本，如“‘Citizen Kane’ (1941)”。如果我们可以搜索这样的文本，同时还可以分别提取电影名称和上映年份，那就太好了。

let re = Regex::new(r"'([^']+)'\s+\((\d{4})\)").unwrap();
let text = "Not my favorite movie: 'Citizen Kane' (1941).";
let caps = re.captures(text).unwrap();
assert_eq!(caps.get(1).unwrap().as_str(), "Citizen Kane");
assert_eq!(caps.get(2).unwrap().as_str(), "1941");
assert_eq!(caps.get(0).unwrap().as_str(), "'Citizen Kane' (1941)");
// You can also access the groups by index using the Index notation.
// Note that this will panic on an invalid index.
assert_eq!(&caps[1], "Citizen Kane");
assert_eq!(&caps[2], "1941");
assert_eq!(&caps[0], "'Citizen Kane' (1941)");

请注意，完全匹配发生在捕获组0。每个后续捕获组按其开始的顺序进行索引 ( 。

通过使用命名的捕获组，我们可以使这个示例更加清晰：

let re = Regex::new(r"'(?P