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 模块
    • 1.2 在 Rust 项目中配置 regex 模块
  • 2. 字符串规则描述符
    • 2.1 定位符:描述字符的边界
    • 2.2 限定符:描述重复匹配的次数
    • 2.3 字符描述
    • 2.4 管道符:“或”匹配逻辑
    • 2.5 转义字符:将特殊符号标识为普通字符
    • 2.6 分组
  • 3. 创建正则表达式对象的方法
    • 3.1 正则对象的字面量
    • 3.2 使用正则表达式字符串
    • 3.3 使用正则表达式字符串和编译选项
    • 3.4 使用正则表达式字符串和编译选项和错误处理
  • 4. 实现其它语言正则中匹配模式标志的功能
    • 4.1 关于匹配模式
    • 4.2 全局匹配
    • 4.3 忽略大小写匹配
    • 4.4 多行匹配模式
    • 4.5 允许 `.` 去匹配新的行
    • 4.6 内联匹配的组合
    • 4.7 视为 Unicode 码位序列
  • 5. Regex API 解析
    • 5.1 核心正则表达式方法
      • 5.1.1 new 方法
        • 描述
      • 5.1.2 is_match 方法
        • 描述
        • 例子
      • 5.1.3 find 方法
        • 描述
        • 例子
      • 5.4 find_iter 方法
        • 描述
        • 例子
      • 5.1.5 captures 方法
        • 描述
        • 例子
      • 5.1.6 captures_iter 方法
        • 描述
        • 例子
      • 5.1.7 split 方法
        • 描述
        • 例子
      • 5.1.8 splitn 方法
        • 描述
        • 例子
      • 5.1.9 replace 方法
        • 描述
        • 替换字符串语法
        • 例子
      • 5.1.10 replace_all 方法
        • 描述
      • 5.1.11 replacen 方法
        • 描述
    • 5.2 高级或“低级”搜索方法
      • 5.2.1 shortest_match 方法
        • 描述
        • 例子
      • 5.2.2 shortest_match_at 方法
        • 描述
        • 例子
      • 5.2.3 is_match_at 方法
        • 描述
        • 例子
      • 5.2.4 find_at 方法
        • 描述
        • 例子
      • 5.2.5 captures_at 方法
        • 描述
        • 例子
      • 5.2.6 captures_read 方法
        • 描述
        • 例子
      • 5.2.7 captures_read_at 方法
        • 描述
        • 例子
    • 5.3 辅助方法
      • 5.3.1 as_str 方法
        • 描述
        • 例子
      • 5.3.2 capture_names 方法
        • 描述
      • 5.3.3 captures_len 方法
        • 描述
      • 5.3.4 static_captures_len 方法
        • 描述
        • 例子
      • 5.3.5 static_captures_len 方法
        • 描述
  • 附录: 查询
    • 元字符表
    • 优先级(从上到下)
    • 内联匹配模式


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 的依赖项:

Rust 笔记:Rust 语言中应用正则表达式_第1张图片

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 限定符:描述重复匹配的次数

符号 描述 说明
? 匹配该限定符前的字符01 等价于 {0,1},如 colou?r 可以匹配colourcolor
+ 匹配该限定符前的字符1 等价于 {1,},如 hel+o可以匹配helohellohelllo、…
* 匹配该限定符前的字符0 等价于 {0,},如 hel*o可以匹配heohelohellohelllo、…
{n} 匹配该限定符前的字符n hel{2}o只可以匹配hello
{n,} 匹配该限定符前的字符最少n次 hel{2,}o可以匹配hellohelllo、…
{n,m} 匹配该限定符前的字符最少n次最多m次 hel{2,3}o只可以匹配hellohelllo

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

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

Rust 笔记:Rust 语言中应用正则表达式_第2张图片

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

管道符就是一根竖线:|,再正则表达式中标识”或“。由于匹配方向时从左向右进行的,假如有两个正则表达式AB,那么使用 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

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

Rust 笔记:Rust 语言中应用正则表达式_第3张图片

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 关于匹配模式

一些语言的正则表达式,如 JavaScriptPython 等等,可以使用一定的形式指定 匹配模式,比如 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 忽略大小写匹配

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

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 内联匹配的组合

你可以使用 ism 的组合,实现同时使用多个匹配模式,如 (?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<RegexError>

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

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

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[^']+)'\s+\((?P<year>\d{4})\)"</span><span class="token punctuation">)</span>
               <span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> text <span class="token operator">=</span> <span class="token string">"Not my favorite movie: 'Citizen Kane' (1941)."</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> caps <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">captures</span><span class="token punctuation">(</span>text<span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span>caps<span class="token punctuation">.</span><span class="token function">name</span><span class="token punctuation">(</span><span class="token string">"title"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">as_str</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token string">"Citizen Kane"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span>caps<span class="token punctuation">.</span><span class="token function">name</span><span class="token punctuation">(</span><span class="token string">"year"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">as_str</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token string">"1941"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span>caps<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span><span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">as_str</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token string">"'Citizen Kane' (1941)"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">// You can also access the groups by name using the Index notation.</span>
<span class="token comment">// Note that this will panic on an invalid group name.</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span><span class="token operator">&</span>caps<span class="token punctuation">[</span><span class="token string">"title"</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token string">"Citizen Kane"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span><span class="token operator">&</span>caps<span class="token punctuation">[</span><span class="token string">"year"</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token string">"1941"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span><span class="token operator">&</span>caps<span class="token punctuation">[</span><span class="token number">0</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token string">"'Citizen Kane' (1941)"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                   <p>这里我们命名捕获组,我们可以用 <code>name</code> 方法或带 <code>&str</code> 的<code>Index</code> 符号来访问它。请注意,使用 <code>get</code> 或带有 <code>usize</code> 的 <code>Index</code> 符号仍然可以访问命名的捕获组。</p> 
                   <p>第 <code>0</code> 个捕获组始终未命名,因此必须始终使用 get(0)<code>或</code>[0]` 来访问它。</p> 
                   <div id="5-1-6"> 
                    <h3><font color="#4B1F9E">5.1.6 captures_iter 方法</font></h3> 
                    <div id="5-1-6-1"></div> 
                    <h4>描述</h4> 
                    <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">captures_iter</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'r</span><span class="token punctuation">,</span> <span class="token lifetime-annotation symbol">'t</span><span class="token operator">></span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token lifetime-annotation symbol">'r</span> <span class="token keyword">self</span><span class="token punctuation">,</span> text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token lifetime-annotation symbol">'t</span> <span class="token keyword">str</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">CaptureMatches</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'r</span><span class="token punctuation">,</span> <span class="token lifetime-annotation symbol">'t</span><span class="token operator">></span>
</code></pre> 
                    <p>返回文本中匹配的所有非重叠捕获组的迭代器。这在操作上与 <code>find_iter</code> 相同,除了它产生关于捕获组匹配的信息。</p> 
                    <div id="5-1-6-2"></div> 
                    <h4>例子</h4> 
                    <p>我们可以使用它在一些文本中查找所有电影名称及其发行年份,其中电影的格式类似于“’ Title’ (xxxx)”:</p> 
                    <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"'(?P<title>[^']+)'\s+\((?P<year>\d{4})\)"</span><span class="token punctuation">)</span>
               <span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> text <span class="token operator">=</span> <span class="token string">"'Citizen Kane' (1941), 'The Wizard of Oz' (1939), 'M' (1931)."</span><span class="token punctuation">;</span>
<span class="token keyword">for</span> caps <span class="token keyword">in</span> re<span class="token punctuation">.</span><span class="token function">captures_iter</span><span class="token punctuation">(</span>text<span class="token punctuation">)</span> <span class="token punctuation">{</span>
    <span class="token macro property">println!</span><span class="token punctuation">(</span><span class="token string">"Movie: {:?}, Released: {:?}"</span><span class="token punctuation">,</span>
             <span class="token operator">&</span>caps<span class="token punctuation">[</span><span class="token string">"title"</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token operator">&</span>caps<span class="token punctuation">[</span><span class="token string">"year"</span><span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre> 
                    <p>输出为:</p> 
                    <pre><code class="prism language-console">Movie: Citizen Kane, Released: 1941
Movie: The Wizard of Oz, Released: 1939
Movie: M, Released: 1931
</code></pre> 
                    <div id="5-1-7"> 
                     <h3><font color="#4B1F9E">5.1.7 split 方法</font></h3> 
                     <div id="5-1-7-1"></div> 
                     <h4>描述</h4> 
                     <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">split</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'r</span><span class="token punctuation">,</span> <span class="token lifetime-annotation symbol">'t</span><span class="token operator">></span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token lifetime-annotation symbol">'r</span> <span class="token keyword">self</span><span class="token punctuation">,</span> text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token lifetime-annotation symbol">'t</span> <span class="token keyword">str</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">Split</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'r</span><span class="token punctuation">,</span> <span class="token lifetime-annotation symbol">'t</span><span class="token operator">></span>
</code></pre> 
                     <p>返回由匹配的正则表达式分隔的文本子字符串的迭代器。也就是说,迭代器的每个元素对应于正则表达式不匹配的文本。</p> 
                     <p>此方法不会复制给定的文本。</p> 
                     <div id="5-1-7-2"></div> 
                     <h4>例子</h4> 
                     <p>要拆分由任意数量的空格或制表符分隔的字符串:</p> 
                     <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"[ \t]+"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> fields<span class="token punctuation">:</span> <span class="token class-name">Vec</span><span class="token operator"><</span><span class="token operator">&</span><span class="token keyword">str</span><span class="token operator">></span> <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">split</span><span class="token punctuation">(</span><span class="token string">"a b \t  c\td    e"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">collect</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span>fields<span class="token punctuation">,</span> <span class="token macro property">vec!</span><span class="token punctuation">[</span><span class="token string">"a"</span><span class="token punctuation">,</span> <span class="token string">"b"</span><span class="token punctuation">,</span> <span class="token string">"c"</span><span class="token punctuation">,</span> <span class="token string">"d"</span><span class="token punctuation">,</span> <span class="token string">"e"</span><span class="token punctuation">]</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                     <div id="5-1-8"> 
                      <h3><font color="#4B1F9E">5.1.8 splitn 方法</font></h3> 
                      <div id="5-1-8-1"></div> 
                      <h4>描述</h4> 
                      <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">splitn</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'r</span><span class="token punctuation">,</span> <span class="token lifetime-annotation symbol">'t</span><span class="token operator">></span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token lifetime-annotation symbol">'r</span> <span class="token keyword">self</span><span class="token punctuation">,</span> text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token lifetime-annotation symbol">'t</span> <span class="token keyword">str</span><span class="token punctuation">,</span> limit<span class="token punctuation">:</span> <span class="token keyword">usize</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">SplitN</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'r</span><span class="token punctuation">,</span> <span class="token lifetime-annotation symbol">'t</span><span class="token operator">></span>
</code></pre> 
                      <p>返回最多有限个文本子字符串的迭代器,这些子字符串由正则表达式的匹配项分隔。(限制为0将不会返回任何子字符串。)也就是说,迭代器的每个元素对应于正则表达式不匹配的文本。字符串中未被拆分的剩余部分将是迭代器中的最后一个元素。</p> 
                      <p>此方法不会复制给定的文本。</p> 
                      <div id="5-1-8-2"></div> 
                      <h4>例子</h4> 
                      <p>获取某些文本中的前两个单词:</p> 
                      <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"\W+"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> fields<span class="token punctuation">:</span> <span class="token class-name">Vec</span><span class="token operator"><</span><span class="token operator">&</span><span class="token keyword">str</span><span class="token operator">></span> <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">splitn</span><span class="token punctuation">(</span><span class="token string">"Hey! How are you?"</span><span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">collect</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span>fields<span class="token punctuation">,</span> <span class="token macro property">vec!</span><span class="token punctuation">(</span><span class="token string">"Hey"</span><span class="token punctuation">,</span> <span class="token string">"How"</span><span class="token punctuation">,</span> <span class="token string">"are you?"</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                      <div id="5-1-9"> 
                       <h3><font color="#4B1F9E">5.1.9 replace 方法</font></h3> 
                       <div id="5-1-9-1"></div> 
                       <h4>描述</h4> 
                       <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">replace</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token punctuation">,</span> <span class="token class-name">R</span><span class="token punctuation">:</span> <span class="token class-name">Replacer</span><span class="token operator">></span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">,</span> text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token lifetime-annotation symbol">'t</span> <span class="token keyword">str</span><span class="token punctuation">,</span> rep<span class="token punctuation">:</span> <span class="token class-name">R</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">Cow</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token punctuation">,</span> <span class="token keyword">str</span><span class="token operator">></span>
</code></pre> 
                       <p>用提供的替换项替换最左边的第一个匹配项。替换可以是一个常规字符串(其中<span class="katex--inline"><span class="katex"><span class="katex-mathml"> N 和 N和 </span><span class="katex-html"><span class="base"><span class="strut" style="height: 0.6833em;"></span><span class="mord mathnormal" style="margin-right: 0.109em;">N</span><span class="mord cjk_fallback">和</span></span></span></span></span>name被扩展以匹配捕获组),也可以是一个获取匹配捕获并返回替换字符串的函数。</p> 
                       <p>如果没有找到匹配,则返回该字符串的副本,不做任何更改。</p> 
                       <div id="5-1-9-2"></div> 
                       <h4>替换字符串语法</h4> 
                       <p>替换文本中 <code>$name</code> 的所有实例都将替换为相应的捕获组 <code>name</code>。</p> 
                       <p><code>name</code> 可以是与捕获组的索引相对应的整数(按左括号的顺序计数,其中0表示整个匹配),也可以是与命名的捕获组相对应的名称(由字母、数字或下划线组成)。</p> 
                       <p>如果 <code>name</code> 不是有效的捕获组(无论该名称不存在还是不是有效的索引),那么它将被替换为空字符串。</p> 
                       <p>使用尽可能长的名称。例如,<code>$1a</code> 查找名为 <code>1a</code> 的捕获组,而不是索引 <code>1</code> 处的捕获组。要对名称进行更精确的控制,请使用大括号,例如 <code>${1}a</code>。</p> 
                       <p>要编写文字 <code>$</code>请使用<code>$$</code>。</p> 
                       <div id="5-1-9-3"></div> 
                       <h4>例子</h4> 
                       <p>注意,这个函数对于替换是多态的。在典型的用法中,这可能只是一个普通的字符串:</p> 
                       <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">"[^01]+"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span>re<span class="token punctuation">.</span><span class="token function">replace</span><span class="token punctuation">(</span><span class="token string">"1078910"</span><span class="token punctuation">,</span> <span class="token string">""</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token string">"1010"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                       <p>但是任何满足替代品特性的东西都可以工作。例如,类型为 <code>|&Captures| -> String</code> 的闭包提供了对与匹配相对应的捕获的直接访问。这允许人们容易地访问捕获组匹配:</p> 
                       <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"([^,\s]+),\s+(\S+)"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> result <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">replace</span><span class="token punctuation">(</span><span class="token string">"Springsteen, Bruce"</span><span class="token punctuation">,</span> <span class="token closure-params"><span class="token closure-punctuation punctuation">|</span>caps<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token class-name">Captures</span><span class="token closure-punctuation punctuation">|</span></span> <span class="token punctuation">{</span>
    <span class="token macro property">format!</span><span class="token punctuation">(</span><span class="token string">"{} {}"</span><span class="token punctuation">,</span> <span class="token operator">&</span>caps<span class="token punctuation">[</span><span class="token number">2</span><span class="token punctuation">]</span><span class="token punctuation">,</span> <span class="token operator">&</span>caps<span class="token punctuation">[</span><span class="token number">1</span><span class="token punctuation">]</span><span class="token punctuation">)</span>
<span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span>result<span class="token punctuation">,</span> <span class="token string">"Bruce Springsteen"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                       <p>但是一直使用这个有点麻烦。相反,支持一个简单的语法,将 <code>$name</code> 展开到相应的捕获组中。这是最后一个示例,但是使用命名捕获组的扩展技术:</p> 
                       <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"(?P<last>[^,\s]+),\s+(?P<first>\S+)"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> result <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">replace</span><span class="token punctuation">(</span><span class="token string">"Springsteen, Bruce"</span><span class="token punctuation">,</span> <span class="token string">"$first $last"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span>result<span class="token punctuation">,</span> <span class="token string">"Bruce Springsteen"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                       <p>请注意,使用 <code>$2</code> 而不是 <code>$first</code> 或 <code>$1</code> 而不是 <code>$last</code> 会产生相同的结果。要编写文字 <code>$</code> 请使用 <code>$$</code>。</p> 
                       <p>有时,替换字符串需要使用花括号来描述捕获组替换和周围的文字文本。例如,如果我们想用下划线将两个单词连在一起:</p> 
                       <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"(?P<first>\w+)\s+(?P<second>\w+)"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> result <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">replace</span><span class="token punctuation">(</span><span class="token string">"deep fried"</span><span class="token punctuation">,</span> <span class="token string">"${first}_$second"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span>result<span class="token punctuation">,</span> <span class="token string">"deep_fried"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                       <p>如果没有花括号,将使用捕获组名 <code>first_</code> 因为它不存在,所以将被空字符串替换。</p> 
                       <p>最后,有时您只想替换一个文字字符串,而不考虑捕获组扩展。这可以通过用NoExpand包装一个字节字符串来实现:</p> 
                       <pre><code class="prism language-rust"><span class="token keyword">use</span> <span class="token namespace">regex<span class="token punctuation">::</span></span><span class="token class-name">NoExpand</span><span class="token punctuation">;</span>

<span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"(?P<last>[^,\s]+),\s+(\S+)"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> result <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">replace</span><span class="token punctuation">(</span><span class="token string">"Springsteen, Bruce"</span><span class="token punctuation">,</span> <span class="token class-name">NoExpand</span><span class="token punctuation">(</span><span class="token string">"$2 $last"</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span>result<span class="token punctuation">,</span> <span class="token string">"$2 $last"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                       <div id="5-1-10"> 
                        <h3><font color="#4B1F9E">5.1.10 replace_all 方法</font></h3> 
                        <div id="5-1-10-1"></div> 
                        <h4>描述</h4> 
                        <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">replace_all</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token punctuation">,</span> <span class="token class-name">R</span><span class="token punctuation">:</span> <span class="token class-name">Replacer</span><span class="token operator">></span><span class="token punctuation">(</span>
    <span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">,</span>
    text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token lifetime-annotation symbol">'t</span> <span class="token keyword">str</span><span class="token punctuation">,</span>
    rep<span class="token punctuation">:</span> <span class="token class-name">R</span>
<span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">Cow</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token punctuation">,</span> <span class="token keyword">str</span><span class="token operator">></span>
</code></pre> 
                        <p>用提供的替换内容替换文本中所有不重叠的匹配内容。这与调用limit设置为0的replacen是一样的。</p> 
                        <div id="5-1-11"> 
                         <h3><font color="#4B1F9E">5.1.11 replacen 方法</font></h3> 
                         <div id="5-1-11-1"></div> 
                         <h4>描述</h4> 
                         <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">replacen</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token punctuation">,</span> <span class="token class-name">R</span><span class="token punctuation">:</span> <span class="token class-name">Replacer</span><span class="token operator">></span><span class="token punctuation">(</span>
    <span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">,</span>
    text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token lifetime-annotation symbol">'t</span> <span class="token keyword">str</span><span class="token punctuation">,</span>
    limit<span class="token punctuation">:</span> <span class="token keyword">usize</span><span class="token punctuation">,</span>
    rep<span class="token punctuation">:</span> <span class="token class-name">R</span>
<span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">Cow</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token punctuation">,</span> <span class="token keyword">str</span><span class="token operator">></span>
</code></pre> 
                         <div id="5-2"> 
                          <h2><font color="#037781">5.2 高级或“低级”搜索方法</font></h2> 
                          <div id="5-2-1"> 
                           <h3><font color="#4B1F9E">5.2.1 shortest_match 方法</font></h3> 
                           <h4>描述</h4> 
                           <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">shortest_match</span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">,</span> text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token keyword">str</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">Option</span><span class="token operator"><</span><span class="token keyword">usize</span><span class="token operator">></span>
</code></pre> 
                           <p>返回给定文本中匹配的结束位置。</p> 
                           <p>该方法可以具有与 <code>is_match</code> 相同的性能特征,除了它提供了匹配的结束位置。特别是,返回的位置可能比通过 <code>Regex::find</code> 找到的最左边第一个匹配的正确结尾要短。</p> 
                           <p>注意,不能保证这个例程找到最短或“最早”的可能匹配。相反,这个 API 的主要思想是,它返回内部正则表达式引擎确定发生匹配的点的偏移量。这可能因使用的内部正则表达式引擎而异,因此偏移量本身可能会改变。</p> 
                           <h4>例子</h4> 
                           <p>通常,<code>a+</code> 会匹配某个文本中 <code>a</code> 的整个第一个序列,但是<code>shortest_match</code> 一看到第一个 <code>a</code> 就会放弃:</p> 
                           <pre><code class="prism language-rust"><span class="token keyword">let</span> text <span class="token operator">=</span> <span class="token string">"aaaaa"</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> pos <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"a+"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">shortest_match</span><span class="token punctuation">(</span>text<span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span>pos<span class="token punctuation">,</span> <span class="token class-name">Some</span><span class="token punctuation">(</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                           <div id="5-2-2"> 
                            <h3><font color="#4B1F9E">5.2.2 shortest_match_at 方法</font></h3> 
                            <h4>描述</h4> 
                            <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">shortest_match_at</span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">,</span> text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token keyword">str</span><span class="token punctuation">,</span> start<span class="token punctuation">:</span> <span class="token keyword">usize</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">Option</span><span class="token operator"><</span><span class="token keyword">usize</span><span class="token operator">></span>
</code></pre> 
                            <p>返回与 <code>shortest_match</code> 相同的值,但从给定的偏移量开始搜索。</p> 
                            <p>起点的意义在于它考虑了周围的环境。例如,<code>\A</code> 定位点只能在 <code>start == 0</code> 时匹配。</p> 
                            <h4>例子</h4> 
                            <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"\d+"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token comment">// 在字符串中查找最短匹配</span>
<span class="token keyword">let</span> text <span class="token operator">=</span> <span class="token string">"123456789"</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> shortest_match <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">shortest_match_at</span><span class="token punctuation">(</span>text<span class="token punctuation">,</span> <span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token macro property">println!</span><span class="token punctuation">(</span><span class="token string">"Shortest match found at index {}"</span><span class="token punctuation">,</span> shortest_match<span class="token punctuation">.</span><span class="token function">end</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                            <div id="5-2-3"> 
                             <h3><font color="#4B1F9E">5.2.3 is_match_at 方法</font></h3> 
                             <h4>描述</h4> 
                             <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">is_match_at</span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">,</span> text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token keyword">str</span><span class="token punctuation">,</span> start<span class="token punctuation">:</span> <span class="token keyword">usize</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token keyword">bool</span>
</code></pre> 
                             <p>返回与 <code>is_match</code> 相同的值,但从给定的偏移量开始搜索。</p> 
                             <p>起点的意义在于它考虑了周围的环境。例如,<code>\A</code> 锚点只能在 <code>start == 0</code> 时匹配。</p> 
                             <h4>例子</h4> 
                             <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"\d{3}-\d{2}-\d{4}"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> s <span class="token operator">=</span> <span class="token string">"123-45-6789"</span><span class="token punctuation">;</span>

<span class="token comment">// 使用is_match_at方法判断字符串是否匹配正则表达式</span>
<span class="token keyword">if</span> re<span class="token punctuation">.</span><span class="token function">is_match_at</span><span class="token punctuation">(</span>s<span class="token punctuation">,</span> <span class="token number">0</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
    <span class="token macro property">println!</span><span class="token punctuation">(</span><span class="token string">"Matched!"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span> <span class="token keyword">else</span> <span class="token punctuation">{</span>
    <span class="token macro property">println!</span><span class="token punctuation">(</span><span class="token string">"Not matched!"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre> 
                             <div id="5-2-4"> 
                              <h3><font color="#4B1F9E">5.2.4 find_at 方法</font></h3> 
                              <h4>描述</h4> 
                              <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">find_at</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token operator">></span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">,</span> text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token lifetime-annotation symbol">'t</span> <span class="token keyword">str</span><span class="token punctuation">,</span> start<span class="token punctuation">:</span> <span class="token keyword">usize</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">Option</span><span class="token operator"><</span><span class="token class-name">Match</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token operator">>></span>
</code></pre> 
                              <p>返回与 <code>find</code> 相同的值,但从给定的偏移量开始搜索。</p> 
                              <p>起点的意义在于它考虑了周围的环境。例如,<code>\A</code> 锚点只能在 <code>start == 0</code> 时匹配。</p> 
                              <h4>例子</h4> 
                              <pre><code class="prism language-rust"><span class="token keyword">let</span> s <span class="token operator">=</span> <span class="token string">"hello world"</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"world"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token comment">// 使用find_at方法查找字符串中第一个匹配正则表达式的位置</span>
<span class="token keyword">let</span> pos <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">find_at</span><span class="token punctuation">(</span>s<span class="token punctuation">,</span> <span class="token number">0</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">start</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token comment">// 输出匹配位置</span>
<span class="token macro property">println!</span><span class="token punctuation">(</span><span class="token string">"Match found at position: {}"</span><span class="token punctuation">,</span> pos<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                              <div id="5-2-5"> 
                              <h3><font color="#4B1F9E">5.2.5 captures_at 方法</font></h3> 
                              <h4>描述</h4> 
                              <pre><code class="prism language-rust">ub <span class="token keyword">fn</span> <span class="token function-definition function">captures_at</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token operator">></span><span class="token punctuation">(</span>
    <span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">,</span>
    text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token lifetime-annotation symbol">'t</span> <span class="token keyword">str</span><span class="token punctuation">,</span>
    start<span class="token punctuation">:</span> <span class="token keyword">usize</span>
<span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">Option</span><span class="token operator"><</span><span class="token class-name">Captures</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token operator">>></span>
</code></pre> 
                              <p>返回与 <code>Regex::captures</code> 相同的值,但从给定的偏移量开始搜索。</p> 
                              <p>起点的意义在于它考虑了周围的环境。例如,<code>\A</code> 锚点只能在 <code>start == 0</code> 时匹配。</p> 
                              <h4>例子</h4> 
                              <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"(\d{4})-(\d{2})-(\d{2})"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> text <span class="token operator">=</span> <span class="token string">"2022-10-31"</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> year <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">captures_at</span><span class="token punctuation">(</span>text<span class="token punctuation">,</span> <span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">as_str</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> month <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">captures_at</span><span class="token punctuation">(</span>text<span class="token punctuation">,</span> <span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">as_str</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> day <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">captures_at</span><span class="token punctuation">(</span>text<span class="token punctuation">,</span> <span class="token number">3</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">as_str</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">println!</span><span class="token punctuation">(</span><span class="token string">"Year: {}, Month: {}, Day: {}"</span><span class="token punctuation">,</span> year<span class="token punctuation">,</span> month<span class="token punctuation">,</span> day<span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                              <div id="5-2-6"> 
                              <h3><font color="#4B1F9E">5.2.6 captures_read 方法</font></h3> 
                              <h4>描述</h4> 
                              <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">captures_read</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token operator">></span><span class="token punctuation">(</span>
    <span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">,</span>
    locs<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token keyword">mut</span> <span class="token class-name">CaptureLocations</span><span class="token punctuation">,</span>
    text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token lifetime-annotation symbol">'t</span> <span class="token keyword">str</span>
<span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">Option</span><span class="token operator"><</span><span class="token class-name">Match</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token operator">>></span>
</code></pre> 
                              <p>这类似于 <code>captures</code> ,但使用 <code>CaptureLocations</code> 而不是 <code>Captures</code> 来分摊分配。</p> 
                              <p>若要创建 <code>CaptureLocations</code> 值,请使用<code>Regex::capture_locations</code> 方法。</p> 
                              <p>如果匹配成功,将返回总匹配,总匹配等同于第 <code>0</code> 个捕获组。</p> 
                              <h4>例子</h4> 
                              <pre><code class="prism language-rust"><span class="token comment">// 用于匹配字符串中的数字</span>
<span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"\d+"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> test_str <span class="token operator">=</span> <span class="token string">"abc123def456ghi789jkl"</span><span class="token punctuation">;</span>

<span class="token comment">// 使用captures_read方法,从字符串中读取匹配到的数字</span>
<span class="token keyword">let</span> <span class="token keyword">mut</span> captures <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">captures_read</span><span class="token punctuation">(</span>test_str<span class="token punctuation">.</span><span class="token function">as_bytes</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token comment">// 遍历匹配到的数字</span>
<span class="token keyword">while</span> <span class="token keyword">let</span> <span class="token class-name">Some</span><span class="token punctuation">(</span>capture<span class="token punctuation">)</span> <span class="token operator">=</span> captures<span class="token punctuation">.</span><span class="token function">next</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
    <span class="token macro property">println!</span><span class="token punctuation">(</span><span class="token string">"{}"</span><span class="token punctuation">,</span> <span class="token namespace">std<span class="token punctuation">::</span></span><span class="token keyword">str</span><span class="token punctuation">::</span><span class="token function">from_utf8</span><span class="token punctuation">(</span>capture<span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">as_bytes</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre> 
                              <div id="5-2-7"> 
                              <h3><font color="#4B1F9E">5.2.7 captures_read_at 方法</font></h3> 
                              <h4>描述</h4> 
                              <pre><code class="prism language-rust"> <span class="token keyword">fn</span> <span class="token function-definition function">captures_read_at</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token operator">></span><span class="token punctuation">(</span>
    <span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">,</span>
    locs<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token keyword">mut</span> <span class="token class-name">CaptureLocations</span><span class="token punctuation">,</span>
    text<span class="token punctuation">:</span> <span class="token operator">&</span><span class="token lifetime-annotation symbol">'t</span> <span class="token keyword">str</span><span class="token punctuation">,</span>
    start<span class="token punctuation">:</span> <span class="token keyword">usize</span>
<span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">Option</span><span class="token operator"><</span><span class="token class-name">Match</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'t</span><span class="token operator">>></span>
</code></pre> 
                              <p>返回与捕获相同的值,但从给定的偏移量开始搜索,并填充给定的捕获位置。</p> 
                              <p>起点的意义在于它考虑了周围的环境。例如,\A锚点只能在start == 0时匹配。</p> 
                              <h4>例子</h4> 
                              <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"(\d{4})-(\d{2})-(\d{2})"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> text <span class="token operator">=</span> <span class="token string">"Today is 2022-01-01."</span><span class="token punctuation">;</span>
<span class="token keyword">if</span> <span class="token keyword">let</span> <span class="token class-name">Some</span><span class="token punctuation">(</span>captures<span class="token punctuation">)</span> <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">captures</span><span class="token punctuation">(</span>text<span class="token punctuation">)</span> <span class="token punctuation">{</span>
    <span class="token macro property">println!</span><span class="token punctuation">(</span><span class="token string">"Year: {}, Month: {}, Day: {}"</span><span class="token punctuation">,</span> captures<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">as_str</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> captures<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">as_str</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> captures<span class="token punctuation">.</span><span class="token function">get</span><span class="token punctuation">(</span><span class="token number">3</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">as_str</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span> <span class="token keyword">else</span> <span class="token punctuation">{</span>
    <span class="token macro property">println!</span><span class="token punctuation">(</span><span class="token string">"No match found"</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre> 
                              <div id="5-3"> 
                              <h2><font color="#037781">5.3 辅助方法</font></h2> 
                              <div id="5-3-1"> 
                              <h3><font color="#4B1F9E">5.3.1 as_str 方法</font></h3> 
                              <h4>描述</h4> 
                              <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">as_str</span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token operator">&</span><span class="token keyword">str</span>
</code></pre> 
                              <p>返回该正则表达式的原始字符串。</p> 
                              <h4>例子</h4> 
                              <pre><code class="prism language-rust"><span class="token keyword">let</span> re <span class="token operator">=</span> <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span><span class="token string">r"\d+"</span><span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> text <span class="token operator">=</span> <span class="token string">"2021-08-01"</span><span class="token punctuation">;</span>
<span class="token keyword">let</span> result <span class="token operator">=</span> re<span class="token punctuation">.</span><span class="token function">find</span><span class="token punctuation">(</span>text<span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">unwrap</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">println!</span><span class="token punctuation">(</span><span class="token string">"{}"</span><span class="token punctuation">,</span> result<span class="token punctuation">.</span><span class="token function">as_str</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                              <div id="5-3-2"> 
                              <h3><font color="#4B1F9E">5.3.2 capture_names 方法</font></h3> 
                              <h4>描述</h4> 
                              <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">capture_names</span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">CaptureNames</span><span class="token operator"><</span><span class="token lifetime-annotation symbol">'_</span><span class="token operator">></span>
</code></pre> 
                              <p>返回捕获名称的迭代器。</p> 
                              <div id="5-3-3"> 
                              <h3><font color="#4B1F9E">5.3.3 captures_len 方法</font></h3> 
                              <h4>描述</h4> 
                              <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">captures_len</span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token keyword">usize</span>
</code></pre> 
                              <p>返回捕获的数量。</p> 
                              <div id="5-3-4"> 
                              <h3><font color="#4B1F9E">5.3.4 static_captures_len 方法</font></h3> 
                              <h4>描述</h4> 
                              <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">static_captures_len</span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">Option</span><span class="token operator"><</span><span class="token keyword">usize</span><span class="token operator">></span>
</code></pre> 
                              <p>返回出现在每个可能匹配项中的捕获组的总数。</p> 
                              <p>如果捕获组的数量因匹配而异,则返回 <code>None</code>。也就是说,只有当匹配组的数量不变或“static”时,才会返回值。</p> 
                              <p>注意,像 <code>Regex::captures_len</code> 一样,这也包含了对应于整个匹配的隐式捕获组。因此,当返回一个非 <code>None</code> 值时,它保证至少为 <code>1</code>。换句话说,返回值 <code>Some(0)</code> 是不可能的。</p> 
                              <h4>例子</h4> 
                              <p>这个例子显示了静态数量的捕获组可用和不可用的几种情况。</p> 
                              <pre><code class="prism language-rust"><span class="token keyword">use</span> <span class="token namespace">regex<span class="token punctuation">::</span></span><span class="token class-name">Regex</span><span class="token punctuation">;</span>

<span class="token keyword">let</span> len <span class="token operator">=</span> <span class="token closure-params"><span class="token closure-punctuation punctuation">|</span>pattern<span class="token closure-punctuation punctuation">|</span></span> <span class="token punctuation">{</span>
    <span class="token class-name">Regex</span><span class="token punctuation">::</span><span class="token function">new</span><span class="token punctuation">(</span>pattern<span class="token punctuation">)</span><span class="token punctuation">.</span><span class="token function">map</span><span class="token punctuation">(</span><span class="token closure-params"><span class="token closure-punctuation punctuation">|</span>re<span class="token closure-punctuation punctuation">|</span></span> re<span class="token punctuation">.</span><span class="token function">static_captures_len</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">)</span>
<span class="token punctuation">}</span><span class="token punctuation">;</span>

<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span><span class="token class-name">Some</span><span class="token punctuation">(</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">len</span><span class="token punctuation">(</span><span class="token string">"a"</span><span class="token punctuation">)</span><span class="token operator">?</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span><span class="token class-name">Some</span><span class="token punctuation">(</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">len</span><span class="token punctuation">(</span><span class="token string">"(a)"</span><span class="token punctuation">)</span><span class="token operator">?</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span><span class="token class-name">Some</span><span class="token punctuation">(</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">len</span><span class="token punctuation">(</span><span class="token string">"(a)|(b)"</span><span class="token punctuation">)</span><span class="token operator">?</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span><span class="token class-name">Some</span><span class="token punctuation">(</span><span class="token number">3</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">len</span><span class="token punctuation">(</span><span class="token string">"(a)(b)|(c)(d)"</span><span class="token punctuation">)</span><span class="token operator">?</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span><span class="token class-name">None</span><span class="token punctuation">,</span> <span class="token function">len</span><span class="token punctuation">(</span><span class="token string">"(a)|b"</span><span class="token punctuation">)</span><span class="token operator">?</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span><span class="token class-name">None</span><span class="token punctuation">,</span> <span class="token function">len</span><span class="token punctuation">(</span><span class="token string">"a|(b)"</span><span class="token punctuation">)</span><span class="token operator">?</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span><span class="token class-name">None</span><span class="token punctuation">,</span> <span class="token function">len</span><span class="token punctuation">(</span><span class="token string">"(b)*"</span><span class="token punctuation">)</span><span class="token operator">?</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token macro property">assert_eq!</span><span class="token punctuation">(</span><span class="token class-name">Some</span><span class="token punctuation">(</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">,</span> <span class="token function">len</span><span class="token punctuation">(</span><span class="token string">"(b)+"</span><span class="token punctuation">)</span><span class="token operator">?</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre> 
                              <div id="5-3-5"> 
                              <h3><font color="#4B1F9E">5.3.5 static_captures_len 方法</font></h3> 
                              <h4>描述</h4> 
                              <pre><code class="prism language-rust"><span class="token keyword">pub</span> <span class="token keyword">fn</span> <span class="token function-definition function">capture_locations</span><span class="token punctuation">(</span><span class="token operator">&</span><span class="token keyword">self</span><span class="token punctuation">)</span> <span class="token punctuation">-></span> <span class="token class-name">CaptureLocations</span>
</code></pre> 
                              <p>返回一组空的捕获位置,这些位置可以在多次调用 <code>captures_read</code> 或 <code>captures_read_at</code> 时重用。</p> 
                              <hr> 
                              <div id="F"> 
                              <h1>附录: 查询</h1> 
                              <hr> 
                              <div id="F-1"> 
                              <h2>元字符表</h2> 
                              <table> 
                              <thead> 
                              <tr> 
                              <th align="left">字符</th> 
                              <th align="left">描述</th> 
                              </tr> 
                              </thead> 
                              <tbody> 
                              <tr> 
                              <td align="left"><code>\</code></td> 
                              <td align="left">将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如,‘n’ 匹配字符 “n”。‘\n’ 匹配一个换行符。序列 ‘\’ 匹配 “” 而 “(” 则匹配 “(”。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>^</code></td> 
                              <td align="left">匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性,^ 也匹配 ‘\n’ 或 ‘\r’ 之后的位置。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>$</code></td> 
                              <td align="left">匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性,$ 也匹配 ‘\n’ 或 ‘\r’ 之前的位置。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>*</code></td> 
                              <td align="left">匹配前面的子表达式零次或多次。例如,zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>+</code></td> 
                              <td align="left">匹配前面的子表达式一次或多次。例如,‘zo+’ 能匹配 “zo” 以及 “zoo”,但不能匹配 “z”。+ 等价于 {1,}。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>?</code></td> 
                              <td align="left">匹配前面的子表达式零次或一次。例如,“do(es)?” 可以匹配 “do” 或 “does” 。? 等价于 {0,1}。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>{n}</code></td> 
                              <td align="left">n 是一个非负整数。匹配确定的 n 次。例如,‘o{2}’ 不能匹配 “Bob” 中的 ‘o’,但是能匹配 “food” 中的两个 o。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>{n,}</code></td> 
                              <td align="left">n 是一个非负整数。至少匹配n 次。例如,‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’,但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>{n,m}</code></td> 
                              <td align="left">m 和 n 均为非负整数,其中n <= m。最少匹配 n 次且最多匹配 m 次。例如,“o{1,3}” 将匹配 “fooooood” 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>?</code></td> 
                              <td align="left">当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时,匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串,而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如,对于字符串 “oooo”,‘o+?’ 将匹配单个 “o”,而 ‘o+’ 将匹配所有 ‘o’。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>.</code></td> 
                              <td align="left">匹配除换行符(\n、\r)之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符,请使用像"<strong>(.|\n)</strong>"的模式。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>(pattern)</code></td> 
                              <td align="left">匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到,在VBScript 中使用 SubMatches 集合,在JScript 中则使用 $0…$9 属性。要匹配圆括号字符,请使用 ‘(’ 或 ‘)’。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>(?:pattern)</code></td> 
                              <td align="left">匹配 pattern 但不获取匹配结果,也就是说这是一个非获取匹配,不进行存储供以后使用。这在使用 “或” 字符 (|) 来组合一个模式的各个部分是很有用。例如, 'industr(?:y|ies) 就是一个比 ‘industry|industries’ 更简略的表达式。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>(?=pattern)</code></td> 
                              <td align="left">正向肯定预查(look ahead positive assert),在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如,“Windows(?=95|98|NT|2000)“能匹配"Windows2000"中的"Windows”,但不能匹配"Windows3.1"中的"Windows”。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>(?!pattern)</code></td> 
                              <td align="left">正向否定预查(negative assert),在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配,也就是说,该匹配不需要获取供以后使用。例如"Windows(?!95|98|NT|2000)“能匹配"Windows3.1"中的"Windows”,但不能匹配"Windows2000"中的"Windows"。预查不消耗字符,也就是说,在一个匹配发生后,在最后一次匹配之后立即开始下一次匹配的搜索,而不是从包含预查的字符之后开始。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>(?<=pattern)</code></td> 
                              <td align="left">反向(look behind)肯定预查,与正向肯定预查类似,只是方向相反。例如,"`(?<=95</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>(?<!pattern)</code></td> 
                              <td align="left">反向否定预查,与正向否定预查类似,只是方向相反。例如"`(?<!95</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>x|y</code></td> 
                              <td align="left">匹配 x 或 y。例如,‘z|food’ 能匹配 “z” 或 “food”。‘(z|f)ood’ 则匹配 “zood” 或 “food”。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>[xyz]</code></td> 
                              <td align="left">字符集合。匹配所包含的任意一个字符。例如, ‘[abc]’ 可以匹配 “plain” 中的 ‘a’。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>[^xyz]</code></td> 
                              <td align="left">负值字符集合。匹配未包含的任意字符。例如, ‘[^abc]’ 可以匹配 “plain” 中的’p’、‘l’、‘i’、‘n’。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>[a-z]</code></td> 
                              <td align="left">字符范围。匹配指定范围内的任意字符。例如,‘[a-z]’ 可以匹配 ‘a’ 到 ‘z’ 范围内的任意小写字母字符。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>[^a-z]</code></td> 
                              <td align="left">负值字符范围。匹配任何不在指定范围内的任意字符。例如,‘[^a-z]’ 可以匹配任何不在 ‘a’ 到 ‘z’ 范围内的任意字符。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\b</code></td> 
                              <td align="left">匹配一个单词边界,也就是指单词和空格间的位置。例如, ‘er\b’ 可以匹配"never" 中的 ‘er’,但不能匹配 “verb” 中的 ‘er’。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\B</code></td> 
                              <td align="left">匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’,但不能匹配 “never” 中的 ‘er’。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\cx</code></td> 
                              <td align="left">匹配由 x 指明的控制字符。例如, \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则,将 c 视为一个原义的 ‘c’ 字符。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\d</code></td> 
                              <td align="left">匹配一个数字字符。等价于 [0-9]。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\D</code></td> 
                              <td align="left">匹配一个非数字字符。等价于 [^0-9]。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\f</code></td> 
                              <td align="left">匹配一个换页符。等价于 \x0c 和 \cL。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\n</code></td> 
                              <td align="left">匹配一个换行符。等价于 \x0a 和 \cJ。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\r</code></td> 
                              <td align="left">匹配一个回车符。等价于 \x0d 和 \cM。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\s</code></td> 
                              <td align="left">匹配任何空白字符,包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\S</code></td> 
                              <td align="left">匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\t</code></td> 
                              <td align="left">匹配一个制表符。等价于 \x09 和 \cI。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\v</code></td> 
                              <td align="left">匹配一个垂直制表符。等价于 \x0b 和 \cK。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\w</code></td> 
                              <td align="left">匹配字母、数字、下划线。等价于’[A-Za-z0-9_]'。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\W</code></td> 
                              <td align="left">匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\xn</code></td> 
                              <td align="left">匹配 n,其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如,‘\x41’ 匹配 “A”。‘\x041’ 则等价于 ‘\x04’ & “1”。正则表达式中可以使用 ASCII 编码。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\num</code></td> 
                              <td align="left">匹配 num,其中 num 是一个正整数。对所获取的匹配的引用。例如,‘(.)\1’ 匹配两个连续的相同字符。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\n</code></td> 
                              <td align="left">标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式,则 n 为向后引用。否则,如果 n 为八进制数字 (0-7),则 n 为一个八进制转义值。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\nm</code></td> 
                              <td align="left">标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式,则 nm 为向后引用。如果 \nm 之前至少有 n 个获取,则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足,若 n 和 m 均为八进制数字 (0-7),则 \nm 将匹配八进制转义值 nm。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\nml</code></td> 
                              <td align="left">如果 n 为八进制数字 (0-3),且 m 和 l 均为八进制数字 (0-7),则匹配八进制转义值 nml。</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>\un</code></td> 
                              <td align="left">匹配 n,其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如, \u00A9 匹配版权符号 (?)。</td> 
                              </tr> 
                              </tbody> 
                              </table> 
                              <div id="F-2"> 
                              <h2>优先级(从上到下)</h2> 
                              <table> 
                              <thead> 
                              <tr> 
                              <th align="left">运算符</th> 
                              <th align="left">描述</th> 
                              </tr> 
                              </thead> 
                              <tbody> 
                              <tr> 
                              <td align="left"><code>\</code></td> 
                              <td align="left">转义符</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>()</code>, <code>(?:)</code>, <code>(?=)</code>, <code>[]</code> 圆括号和方括号</td> 
                              <td align="left"></td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>*</code>, <code>+</code>, <code>?</code>, <code>{n}</code>, <code>{n,}</code>, <code>{n,m}</code></td> 
                              <td align="left">限定符</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>^</code>, <code>$</code>, \任何元字符、任何字符</td> 
                              <td align="left">定位点和序列(即:位置和顺序)</td> 
                              </tr> 
                              <tr> 
                              <td align="left">`</td> 
                              <td align="left">`</td> 
                              </tr> 
                              </tbody> 
                              </table> 
                              <div id="F-3"> 
                              <h2>内联匹配模式</h2> 
                              <table> 
                              <thead> 
                              <tr> 
                              <th align="left">匹配模式语法</th> 
                              <th align="left">描述</th> 
                              </tr> 
                              </thead> 
                              <tbody> 
                              <tr> 
                              <td align="left"><code>(?i)</code></td> 
                              <td align="left">右侧的表达式忽略大小写</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>(?s)</code></td> 
                              <td align="left">右侧的表达式单行匹配</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>(?m)</code></td> 
                              <td align="left">右侧的表示式开启指定多行</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>(?is)</code></td> 
                              <td align="left">右侧的表示式忽略大小写 且 单行匹配</td> 
                              </tr> 
                              <tr> 
                              <td align="left"><code>(?im)</code></td> 
                              <td align="left">右侧的表示式忽略大小写 且 多行匹配</td> 
                              </tr> 
                              </tbody> 
                              </table> 
                              </div> 
                              </div> 
                              </div> 
                              </div> 
                              </div> 
                              </div> 
                              </div> 
                              </div> 
                              </div> 
                              </div> 
                              </div> 
                              </div> 
                              </div> 
                             </div> 
                            </div> 
                           </div> 
                          </div> 
                         </div> 
                        </div> 
                       </div> 
                      </div> 
                     </div> 
                    </div> 
                   </div> 
                  </div> 
                 </div> 
                </div> 
               </div> 
              </div> 
             </div> 
            </div> 
           </div> 
          </div> 
         </div> 
        </div> 
       </div> 
      </div> 
     </div> 
    </div> 
   </div> 
  </div> 
 </div> 
</div>
                            </div>
                        </div>
                    </div>
                    <!--PC和WAP自适应版-->
                    <div id="SOHUCS" sid="1670407344590249984"></div>
                    <script type="text/javascript" src="/views/front/js/chanyan.js"></script>
                    <!-- 文章页-底部 动态广告位 -->
                    <div class="youdao-fixed-ad" id="detail_ad_bottom"></div>
                </div>
                <div class="col-md-3">
                    <div class="row" id="ad">
                        <!-- 文章页-右侧1 动态广告位 -->
                        <div id="right-1" class="col-lg-12 col-md-12 col-sm-4 col-xs-4 ad">
                            <div class="youdao-fixed-ad" id="detail_ad_1"> </div>
                        </div>
                        <!-- 文章页-右侧2 动态广告位 -->
                        <div id="right-2" class="col-lg-12 col-md-12 col-sm-4 col-xs-4 ad">
                            <div class="youdao-fixed-ad" id="detail_ad_2"></div>
                        </div>
                        <!-- 文章页-右侧3 动态广告位 -->
                        <div id="right-3" class="col-lg-12 col-md-12 col-sm-4 col-xs-4 ad">
                            <div class="youdao-fixed-ad" id="detail_ad_3"></div>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </div>
    <div class="container">
        <h4 class="pt20 mb15 mt0 border-top">你可能感兴趣的:(Rust学习笔记,rust,笔记,正则表达式)</h4>
        <div id="paradigm-article-related">
            <div class="recommend-post mb30">
                <ul class="widget-links">
                    <li><a href="/article/1901546201396867072.htm"
                           title="【数学基础】线性代数#1向量和矩阵初步" target="_blank">【数学基础】线性代数#1向量和矩阵初步</a>
                        <span class="text-muted">-一杯为品-</span>
<a class="tag" taget="_blank" href="/search/%E6%95%B0%E5%AD%A6/1.htm">数学</a><a class="tag" taget="_blank" href="/search/%E7%BA%BF%E6%80%A7%E4%BB%A3%E6%95%B0/1.htm">线性代数</a><a class="tag" taget="_blank" href="/search/%E7%9F%A9%E9%98%B5/1.htm">矩阵</a>
                        <div>本系列内容介绍:主要参考资料:《深度学习》[美]伊恩·古德菲洛等著《机器人数学基础》吴福朝张铃著文章为自学笔记,仅供参考。目录标量、向量、矩阵和张量矩阵运算单位矩阵和逆矩阵线性相关和生成子空间范数特殊类型的矩阵和向量特征分解奇异值分解Moore-Penrose伪逆迹运算行列式标量、向量、矩阵和张量标量标量是一个单独的数。向量向量是一列有序排列的数:x=[x1x2⋮xn]\boldsymbolx=\</div>
                    </li>
                    <li><a href="/article/1901533214237847552.htm"
                           title="【APM】Loki日志多行显示" target="_blank">【APM】Loki日志多行显示</a>
                        <span class="text-muted">运维归一</span>
<a class="tag" taget="_blank" href="/search/DevOps/1.htm">DevOps</a><a class="tag" taget="_blank" href="/search/APM/1.htm">APM</a><a class="tag" taget="_blank" href="/search/loki/1.htm">loki</a><a class="tag" taget="_blank" href="/search/%E6%97%A5%E5%BF%97%E5%B9%B6%E8%A1%8C/1.htm">日志并行</a>
                        <div>上一篇文章我们搭建了Alertmanager和Loki,接下来我们来实现日志并行显示专栏:https://blog.csdn.net/zhanremo3062/category_12552674.html我们只需要修改Promtail服务的配置文件即可multiline:#RE2正则表达式,如果匹配将开始一个新的多行日志块#这个表达式必须被提供firstline:#解析的最大等待时间(Godura</div>
                    </li>
                    <li><a href="/article/1901516694304649216.htm"
                           title="信息收集之 子域名收集,子域名爆破_dnsdumpster" target="_blank">信息收集之 子域名收集,子域名爆破_dnsdumpster</a>
                        <span class="text-muted">2401_89829398</span>
<a class="tag" taget="_blank" href="/search/%E7%BD%91%E7%BB%9C/1.htm">网络</a>
                        <div>「作者主页」:士别三日wyx「作者简介」:CSDNtop100、阿里云博客专家、华为云享专家、网络安全领域优质创作者「专栏简介」:此文章已录入专栏《网络安全快速入门》子域名收集一、域名爆破原理二、搜索引擎收集子域名三、第三方网站收集子域名1.VirusTotal2.DNSdumpster四、工具收集子域名子域名就是下一级域名的意思,比如map.baidu.com和image.baidu.com就是</div>
                    </li>
                    <li><a href="/article/1901502321603440640.htm"
                           title="moonligh串流教程以及3大问题解决" target="_blank">moonligh串流教程以及3大问题解决</a>
                        <span class="text-muted">kalada82</span>
<a class="tag" taget="_blank" href="/search/win10%E7%94%B5%E8%84%91%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98%E8%A7%A3%E5%86%B3%E6%96%B9%E6%A1%88/1.htm">win10电脑常见问题解决方案</a><a class="tag" taget="_blank" href="/search/%E8%81%8C%E5%9C%BA%E5%92%8C%E5%8F%91%E5%B1%95/1.htm">职场和发展</a><a class="tag" taget="_blank" href="/search/%E5%B0%8F%E7%A8%8B%E5%BA%8F/1.htm">小程序</a>
                        <div>首先说明,ml和steamlink我不是高下评判,大家自己喜欢用那个就行。ml可以关笔记本屏幕用,不用打开steam手动,我喜欢,还能当远程桌面问题;1软件下载,网上找的,随便用就是了2软件使用,开启gefoce的sheld功能·,把软件串流进去3ml使用闪屏,应为串流打开的屏幕是集显,就会这样,就要屏幕独显直连。台式连接一个外接显示器就行,笔记本买个hdmi欺骗器就行4设置hdmi的分辨率,设置</div>
                    </li>
                    <li><a href="/article/1901499927079481344.htm"
                           title="S7-1200 博途V18 与 win11-24H2 系统 通信问题 有IP但显示节点不兼容????" target="_blank">S7-1200 博途V18 与 win11-24H2 系统 通信问题 有IP但显示节点不兼容????</a>
                        <span class="text-muted">Zp_4944</span>
<a class="tag" taget="_blank" href="/search/tcp%2Fip/1.htm">tcp/ip</a><a class="tag" taget="_blank" href="/search/%E7%BD%91%E7%BB%9C%E5%8D%8F%E8%AE%AE/1.htm">网络协议</a><a class="tag" taget="_blank" href="/search/%E4%BF%A1%E6%81%AF%E4%B8%8E%E9%80%9A%E4%BF%A1/1.htm">信息与通信</a><a class="tag" taget="_blank" href="/search/windows/1.htm">windows</a><a class="tag" taget="_blank" href="/search/%E4%BA%BA%E6%9C%BA%E4%BA%A4%E4%BA%92/1.htm">人机交互</a>
                        <div>博途V18-plc1200在笔记本win11-24H2系统上可访问在线设备时可以搜到plc的ip,但是显示节点不兼容,不能与plc设备建立连接,同时plc显示的ip地址是红色的。换了一个win10的笔记本在线没问题,就把原来win11上的博途V18软件删了,重新安装win10上的博途V18软件,同样的安装发式,设置这些也绝对没有问题,但还是同样连不上plc。关防火墙,以管理员身份运行这些都试过了。</div>
                    </li>
                    <li><a href="/article/1901493245062475776.htm"
                           title="HarmonyOS NEXT开发笔记:@Computed装饰器计算属性" target="_blank">HarmonyOS NEXT开发笔记:@Computed装饰器计算属性</a>
                        <span class="text-muted">我很英俊 小名男男</span>
<a class="tag" taget="_blank" href="/search/OpenHarmony/1.htm">OpenHarmony</a><a class="tag" taget="_blank" href="/search/%E9%B8%BF%E8%92%99%E5%BC%80%E5%8F%91/1.htm">鸿蒙开发</a><a class="tag" taget="_blank" href="/search/HarmonyOS/1.htm">HarmonyOS</a><a class="tag" taget="_blank" href="/search/harmonyos/1.htm">harmonyos</a><a class="tag" taget="_blank" href="/search/%E5%8D%8E%E4%B8%BA/1.htm">华为</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a><a class="tag" taget="_blank" href="/search/%E5%89%8D%E7%AB%AF/1.htm">前端</a><a class="tag" taget="_blank" href="/search/%E9%B8%BF%E8%92%99/1.htm">鸿蒙</a><a class="tag" taget="_blank" href="/search/%E7%A7%BB%E5%8A%A8%E5%BC%80%E5%8F%91/1.htm">移动开发</a><a class="tag" taget="_blank" href="/search/%E9%B8%BF%E8%92%99%E7%B3%BB%E7%BB%9F/1.htm">鸿蒙系统</a>
                        <div>鸿蒙开发往期必看:一分钟了解”纯血版!鸿蒙HarmonyOSNext应用开发!“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线!(从零基础入门到精通)</div>
                    </li>
                    <li><a href="/article/1901466262140153856.htm"
                           title="零信任架构" target="_blank">零信任架构</a>
                        <span class="text-muted">阿湯哥</span>
<a class="tag" taget="_blank" href="/search/%E6%9E%B6%E6%9E%84/1.htm">架构</a>
                        <div>零信任架构(ZeroTrustArchitecture,ZTA)零信任架构是一种新型网络安全模型,核心理念是“永不信任,始终验证”(NeverTrust,AlwaysVerify)。它摒弃传统基于边界的安全防护(如防火墙隔离内外部网络),转而通过动态的、细粒度的访问控制,对所有用户、设备和数据流进行持续验证,最小化攻击面并防范内部威胁。一、零信任与传统安全模型的对比维度传统安全模型零信任模型信任基</div>
                    </li>
                    <li><a href="/article/1901463615769210880.htm"
                           title="Ubuntu常用命令手册【自用笔记】" target="_blank">Ubuntu常用命令手册【自用笔记】</a>
                        <span class="text-muted">大佬橙1215</span>
<a class="tag" taget="_blank" href="/search/Linux/1.htm">Linux</a><a class="tag" taget="_blank" href="/search/ubuntu/1.htm">ubuntu</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a><a class="tag" taget="_blank" href="/search/Linux/1.htm">Linux</a>
                        <div>Ubuntu常用命令手册【自用】目录Ubuntu常用命令手册【自用】1.杂项1.删除进程中包含"smb"字段的所有进程2.查看最近登录的ip2.xargs3.awk4.find5.grep6.sed7.timedatectl1.杂项1.删除进程中包含"smb"字段的所有进程sudokill-9$(ps-aux|grepsmb|awk'{print$2}')2.查看最近登录的ipcat/var/lo</div>
                    </li>
                    <li><a href="/article/1901463253423288320.htm"
                           title="基于HarmonyNext的ArkTS实战:构建高性能跨平台应用" target="_blank">基于HarmonyNext的ArkTS实战:构建高性能跨平台应用</a>
                        <span class="text-muted"></span>
<a class="tag" taget="_blank" href="/search/harmonyos-next/1.htm">harmonyos-next</a>
                        <div>基于HarmonyNext的ArkTS实战:构建高性能跨平台应用引言在HarmonyNext生态系统中,ArkTS作为新一代的编程语言,凭借其强大的类型系统和高效的运行时性能,成为开发高性能跨平台应用的首选。本文将深入探讨如何利用ArkTS构建一个复杂的跨平台应用,涵盖从项目架构设计到具体实现的完整流程。我们将通过一个实战案例——构建一个支持多端同步的笔记应用,来展示ArkTS在HarmonyNe</div>
                    </li>
                    <li><a href="/article/1901455174635941888.htm"
                           title="80或者443端口不能开放也可签发的IP SSL证书" target="_blank">80或者443端口不能开放也可签发的IP SSL证书</a>
                        <span class="text-muted"></span>
<a class="tag" taget="_blank" href="/search/https/1.htm">https</a>
                        <div>以IP地址来申请SSL证书的时候,通常需要以上传服务器文件的方式来验证IP地址的管理权限,这就涉及常规端口的开放,一般需要开放80或者443端口,如不能开放则无法签发SSL证书。DunTrust提供的IP地址证书,除了支持80或者443端口验证外,还支持其他端口验证。申请网址:www.yundunssl.comhttps://www.yundunssl.cn/下面是具体的申请流程注册账号:在Dun</div>
                    </li>
                    <li><a href="/article/1901453030490959872.htm"
                           title="windows协议不再续签,华为再无windows可用,将于四月发布鸿蒙PC" target="_blank">windows协议不再续签,华为再无windows可用,将于四月发布鸿蒙PC</a>
                        <span class="text-muted">国货崛起</span>
<a class="tag" taget="_blank" href="/search/%E5%8D%8E%E4%B8%BA/1.htm">华为</a><a class="tag" taget="_blank" href="/search/harmonyos/1.htm">harmonyos</a>
                        <div>大家好,我是国货系创始人张云泽,最近不少小伙伴在后台问:“听说Windows协议要到期了?我的电脑会不会变砖?”还有人说:“华为笔记本以后用不了Windows了?鸿蒙系统能用吗?”今天咱们就唠唠这事儿,不整虚的!windows协议到期将不再续签,华为将于四月发布鸿蒙PC版一、普通用户的Windows协议到期,慌不慌?其实啊,Windows协议到期一般分两种情况:个人用户:比如用了临时激活码或者第三</div>
                    </li>
                    <li><a href="/article/1901449250236067840.htm"
                           title="33.从入门到精通:Python3 正则表达式 re.match函数 re.search方法 re.match与re.search的区别" target="_blank">33.从入门到精通:Python3 正则表达式 re.match函数 re.search方法 re.match与re.search的区别</a>
                        <span class="text-muted">摘星月为妆。</span>
<a class="tag" taget="_blank" href="/search/Python%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E7%B2%BE%E9%80%9A/1.htm">Python从入门到精通</a><a class="tag" taget="_blank" href="/search/%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/1.htm">正则表达式</a>
                        <div>33.从入门到精通:Python3正则表达式re.match函数re.search方法re.match与re.search的区别Python3正则表达式re.match函数re.search方法re.match与re.search的区别Python3正则表达式在Python3中,可以使用re模块来进行正则表达式的匹配和处理。以下是一个简单的例子,说明如何使用re模块进行正则表达式匹配:import</div>
                    </li>
                    <li><a href="/article/1901447861392961536.htm"
                           title="python中re.search()函数的用法" target="_blank">python中re.search()函数的用法</a>
                        <span class="text-muted">前行的zhu</span>
<a class="tag" taget="_blank" href="/search/pytorch/1.htm">pytorch</a><a class="tag" taget="_blank" href="/search/%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/1.htm">正则表达式</a><a class="tag" taget="_blank" href="/search/%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/1.htm">正则表达式</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a>
                        <div>说到使用正则匹配字符串,就不得不说三个常用的匹配检索方法:re.search(),re.match()和re.findall()。主要的区别是前两个方法只在目标字符串中匹配一次满足条件的正则表达式;而re.findall()方法匹配目标字符串中所有满足条件的正则表达式;另外re.match()只会匹配目标字符串开头是否满足正则表达式,若开头不满足则匹配失败,函数返回None;而re.search(</div>
                    </li>
                    <li><a href="/article/1901447735064719360.htm"
                           title="python 中 Re库 函数 re.search()" target="_blank">python 中 Re库 函数 re.search()</a>
                        <span class="text-muted">weixin_43964993</span>
<a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a>
                        <div>re.search(pattern,string,flags=0)在一个字符串中搜索匹配正则表达式的第一个位置,返回match对象pattern:正则表达式的字符串或原生字符串表示string:待匹配字符串flags:正则表达式使用时的控制标记常用标记说明re.I  re.IGNORECASE忽略正则表达式的大小写,[A‐Z]能够匹配小写字符re.M  re.MULTILINE正则表达式中的^操作</div>
                    </li>
                    <li><a href="/article/1901404612691292160.htm"
                           title="DeepSeek-R1模型1.5b、7b、8b、14b、32b、70b和671b有啥区别?" target="_blank">DeepSeek-R1模型1.5b、7b、8b、14b、32b、70b和671b有啥区别?</a>
                        <span class="text-muted">facaixxx2024</span>
<a class="tag" taget="_blank" href="/search/AI%E5%A4%A7%E6%A8%A1%E5%9E%8B/1.htm">AI大模型</a><a class="tag" taget="_blank" href="/search/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/1.htm">人工智能</a><a class="tag" taget="_blank" href="/search/%E7%AE%97%E6%B3%95/1.htm">算法</a><a class="tag" taget="_blank" href="/search/%E6%B7%B1%E5%BA%A6%E5%AD%A6%E4%B9%A0/1.htm">深度学习</a>
                        <div>deepseek-r1的1.5b、7b、8b、14b、32b、70b和671b有啥区别?码笔记mabiji.com分享:1.5B、7B、8B、14B、32B、70B是蒸馏后的小模型,671B是基础大模型,它们的区别主要体现在参数规模、模型容量、性能表现、准确性、训练成本、推理成本和不同使用场景:deepseek-r1的1.5b、7b、8b、14b、32b、70b和671b参数规模参数规模的区别,模</div>
                    </li>
                    <li><a href="/article/1901395526436319232.htm"
                           title="A survey on instance segmentation: state of the art——论文笔记" target="_blank">A survey on instance segmentation: state of the art——论文笔记</a>
                        <span class="text-muted">栀子清茶</span>
<a class="tag" taget="_blank" href="/search/1024%E7%A8%8B%E5%BA%8F%E5%91%98%E8%8A%82/1.htm">1024程序员节</a><a class="tag" taget="_blank" href="/search/%E8%AE%BA%E6%96%87%E9%98%85%E8%AF%BB/1.htm">论文阅读</a><a class="tag" taget="_blank" href="/search/%E8%AE%A1%E7%AE%97%E6%9C%BA%E8%A7%86%E8%A7%89/1.htm">计算机视觉</a><a class="tag" taget="_blank" href="/search/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/1.htm">人工智能</a><a class="tag" taget="_blank" href="/search/%E7%AC%94%E8%AE%B0/1.htm">笔记</a><a class="tag" taget="_blank" href="/search/%E5%AD%A6%E4%B9%A0/1.htm">学习</a>
                        <div>摘要这篇论文综述了实例分割的研究进展,定义其为同时解决对象检测和语义分割的问题。论文讨论了实例分割的背景、面临的挑战、技术演变、常用数据集,并总结了相关领域的最新成果和未来研究方向。实例分割的发展从粗略的对象分类逐步演变为更精细的像素级别推理,广泛应用于自动驾驶、机器人等领域。论文为研究人员提供了对实例分割领域的全面了解和有价值的参考。一、简介第一部分“简介”主要介绍了实例分割的背景、定义和挑战。</div>
                    </li>
                    <li><a href="/article/1901395021689581568.htm"
                           title="Python第二十三课:自监督学习 | 无标注数据的觉醒" target="_blank">Python第二十三课:自监督学习 | 无标注数据的觉醒</a>
                        <span class="text-muted">程之编</span>
<a class="tag" taget="_blank" href="/search/Python%E5%85%A8%E6%A0%88%E9%80%9A%E5%85%B3%E7%A7%98%E7%B1%8D/1.htm">Python全栈通关秘籍</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a><a class="tag" taget="_blank" href="/search/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/1.htm">人工智能</a><a class="tag" taget="_blank" href="/search/%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0/1.htm">机器学习</a>
                        <div>本节目标理解自监督学习的核心范式与优势掌握对比学习(ContrastiveLearning)框架实现图像掩码自编码器(MaskedAutoencoder)开发实战项目:亿级参数模型轻量化探索数据增强的创造性艺术一、自监督学习基础(AI的拼图游戏)1.核心思想解析学习范式数据需求生活比喻监督学习海量标注数据老师逐题批改作业无监督学习纯无标签数据自学杂乱笔记自监督学习自动生成伪标签玩拼图游戏(根据碎片</div>
                    </li>
                    <li><a href="/article/1901393508950929408.htm"
                           title="简单工厂模式、工厂方法模式、抽象工厂模式 对比学习笔记" target="_blank">简单工厂模式、工厂方法模式、抽象工厂模式 对比学习笔记</a>
                        <span class="text-muted">idgoodbye</span>
<a class="tag" taget="_blank" href="/search/%E7%AE%80%E5%8D%95%E5%B7%A5%E5%8E%82%E6%A8%A1%E5%BC%8F/1.htm">简单工厂模式</a><a class="tag" taget="_blank" href="/search/%E5%B7%A5%E5%8E%82%E6%96%B9%E6%B3%95%E6%A8%A1%E5%BC%8F/1.htm">工厂方法模式</a><a class="tag" taget="_blank" href="/search/%E6%8A%BD%E8%B1%A1%E5%B7%A5%E5%8E%82%E6%A8%A1%E5%BC%8F/1.htm">抽象工厂模式</a>
                        <div>工厂模式架构设计原则开闭原则:是指一个软件实体(如类、模块和函数)应该对扩展开放,对修改关闭。依赖倒置原则:是指设计代码结构时,高层模块不应该依赖低层模块,二者都应该依赖其抽象。抽象不应该依赖细节,细节应该依赖抽象。单一职责:是指一个类只负责一个主要任务,避免因一个类负责两个以上任务时,修改其中一个任务代码导致另一个任务代码受到连带影响。接口隔离原则:是指用多个专门的接口,而不使用单一的总接口,客</div>
                    </li>
                    <li><a href="/article/1901391732302475264.htm"
                           title="zkSync节点部署" target="_blank">zkSync节点部署</a>
                        <span class="text-muted">NO如果</span>
<a class="tag" taget="_blank" href="/search/%E7%AC%94%E8%AE%B0/1.htm">笔记</a><a class="tag" taget="_blank" href="/search/rust/1.htm">rust</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a><a class="tag" taget="_blank" href="/search/%E5%90%8E%E7%AB%AF/1.htm">后端</a>
                        <div>#ZKSYNC节点部署安装依赖1.docker安装2.node3.yarn4.apt-getinstallaxel2.16.1axel--version5.rustcurl--proto'=https'--tlsv1.2-sSfhttps://sh.rustup.rs|shsource$HOME/.cargo/envrustc--version6.lld配置就行7.psqlsudoapt-geti</div>
                    </li>
                    <li><a href="/article/1901382407387410432.htm"
                           title="[rust] rust学习" target="_blank">[rust] rust学习</a>
                        <span class="text-muted">1nv1s1ble</span>
<a class="tag" taget="_blank" href="/search/rust/1.htm">rust</a><a class="tag" taget="_blank" href="/search/rust/1.htm">rust</a><a class="tag" taget="_blank" href="/search/%E5%AD%A6%E4%B9%A0/1.htm">学习</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a>
                        <div>rust学习1.项目组织结构工程#创建一个工程cargonewmy-project工作空间在Rust中,工作空间(Workspace)是一个包含多个Rust项目的共享环境,用于管理多个crate(库或可执行文件)。它允许多个Rust项目共享Cargo.lock、依赖项和target/目录,提高编译效率,并且适用于多包管理、模块化开发。为什么使用Rust工作空间?Rust工作空间适用于以下场景:管理</div>
                    </li>
                    <li><a href="/article/1901379884333199360.htm"
                           title="[特殊字符] 用Rust重塑Web开发速度极限:Hyperlane框架——开启高性能服务的「光年时代」[特殊字符]" target="_blank">[特殊字符] 用Rust重塑Web开发速度极限:Hyperlane框架——开启高性能服务的「光年时代」[特殊字符]</a>
                        <span class="text-muted">LTPP</span>
<a class="tag" taget="_blank" href="/search/rust/1.htm">rust</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a><a class="tag" taget="_blank" href="/search/http/1.htm">http</a><a class="tag" taget="_blank" href="/search/%E6%9C%8D%E5%8A%A1%E5%99%A8/1.htm">服务器</a><a class="tag" taget="_blank" href="/search/%E5%90%8E%E7%AB%AF/1.htm">后端</a><a class="tag" taget="_blank" href="/search/%E7%BD%91%E7%BB%9C%E5%8D%8F%E8%AE%AE/1.htm">网络协议</a><a class="tag" taget="_blank" href="/search/%E9%AB%98%E5%B9%B6%E5%8F%91/1.htm">高并发</a>
                        <div>每秒百万级请求?Rust超新星Hyperlane框架让Web开发突破性能次元壁!颠覆性技术亮点:为何全球顶尖工程师正疯狂迁移至Hyperlane?⚡️「速度即正义」:重新定义Web性能天花板零延迟战场:实测万级并发下延迟低于5ms,让传统框架望尘莫及。Rust内核级优化:基于tokio异步运行时的极致封装,QPS突破5万+,内存占用极低,完美适配边缘计算与云原生场景。️「开发者狂喜」:5分钟极速上</div>
                    </li>
                    <li><a href="/article/1901370807376998400.htm"
                           title="Spring-Boot学习笔记" target="_blank">Spring-Boot学习笔记</a>
                        <span class="text-muted">戴帽子的小熊猫</span>
<a class="tag" taget="_blank" href="/search/%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/1.htm">学习笔记</a><a class="tag" taget="_blank" href="/search/%E5%AD%A6%E4%B9%A0/1.htm">学习</a><a class="tag" taget="_blank" href="/search/%E7%AC%94%E8%AE%B0/1.htm">笔记</a><a class="tag" taget="_blank" href="/search/spring/1.htm">spring</a><a class="tag" taget="_blank" href="/search/boot/1.htm">boot</a>
                        <div>这个笔记是在自己学习的过程中根据实际用到的和学到的整理出来的,可能会有缺失,错误等,主要是给激励自己学习,遇到写不下去的情况给自己一个参考,请各位大佬发现问题提出问题时能嘴下留情,也希望多提建议,谢谢。本笔记长期更新(更新日期2024年9月21日)目录第1章.固定格式参考1.1application.yml1.2mapper.xml(详细操作见另一个文件[XML数据库操作笔记]())1.3appl</div>
                    </li>
                    <li><a href="/article/1901344827505700864.htm"
                           title="html css 笔记" target="_blank">html css 笔记</a>
                        <span class="text-muted">小箌</span>
<a class="tag" taget="_blank" href="/search/html/1.htm">html</a><a class="tag" taget="_blank" href="/search/css/1.htm">css</a><a class="tag" taget="_blank" href="/search/%E7%AC%94%E8%AE%B0/1.htm">笔记</a>
                        <div>01_浏览器相关知识五大主流浏览器:ChromeSafariIEFirefoxOpera(拥有自己的内核)四大内核:webkitTridentGeckoblink.02_网页相关知识构成网址网站网页网页标准:结构表现行为分别对应HTMLCSSJavaScript03_HTML简介HTML是什么译为:标记语言超文本:比普通的文本信息含量更多04_HTML初体验保存:Ctrl+S后缀:.html程序员</div>
                    </li>
                    <li><a href="/article/1901337131662503936.htm"
                           title="Linux命令学习笔记之 network NetworkManager" target="_blank">Linux命令学习笔记之 network NetworkManager</a>
                        <span class="text-muted">kfepiza</span>
<a class="tag" taget="_blank" href="/search/OS%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/1.htm">OS操作系统</a><a class="tag" taget="_blank" href="/search/Windows/1.htm">Windows</a><a class="tag" taget="_blank" href="/search/Linux/1.htm">Linux</a><a class="tag" taget="_blank" href="/search/%E7%AD%89/1.htm">等</a><a class="tag" taget="_blank" href="/search/%23/1.htm">#</a><a class="tag" taget="_blank" href="/search/Linux/1.htm">Linux</a><a class="tag" taget="_blank" href="/search/CentOS/1.htm">CentOS</a><a class="tag" taget="_blank" href="/search/Ubuntu/1.htm">Ubuntu</a><a class="tag" taget="_blank" href="/search/%E7%AD%89/1.htm">等</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E5%AD%A6%E4%B9%A0/1.htm">学习</a><a class="tag" taget="_blank" href="/search/centos/1.htm">centos</a>
                        <div>networkNetworkManager前言CentOS7最小安装下的测试220511心得:启动network能打开网络,关闭network能关闭网络启动NetworkManager能打开网络,关闭不会关闭网络在两者都启动的情况下,单停network会断网,单停NetworkManager不会一些摘抄前言这两个东西在centOS7最小安装无勾选附加时就存在Ubuntu20.04中只有Networ</div>
                    </li>
                    <li><a href="/article/1901334105388281856.htm"
                           title="Linux 命令学习记录" target="_blank">Linux 命令学习记录</a>
                        <span class="text-muted">hxung</span>
<a class="tag" taget="_blank" href="/search/%E9%9D%A2%E8%AF%95%E5%AD%A6%E4%B9%A0%E4%BD%BF%E7%94%A8/1.htm">面试学习使用</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/%E5%AD%A6%E4%B9%A0/1.htm">学习</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a>
                        <div>Linux命令详解与进阶指南Linux是一种广泛使用的开源操作系统,掌握Linux命令是开发者和系统管理员的必备技能。本文将详细介绍Linux的常用命令,并涵盖一些高级进阶技巧,帮助你更高效地使用Linux。目录基础命令文件与目录操作文本处理系统信息权限管理进阶命令进程管理网络操作磁盘管理Shell脚本高级技巧管道与重定向正则表达式任务调度性能监控案例实战日志分析自动化部署服务器监控基础命令文件与</div>
                    </li>
                    <li><a href="/article/1901332592678989824.htm"
                           title="Python——正则表达式与re模块" target="_blank">Python——正则表达式与re模块</a>
                        <span class="text-muted">fw9521</span>
<a class="tag" taget="_blank" href="/search/python/1.htm">python</a>
                        <div>目录1.正则表达式2.re模块函数-findall3.re模块函数-search4.re函数模块-sub总结1.正则表达式正则:为了匹配一个符合规则的字符串1.精确匹配:abc:匹配abc的子串2.选择性匹配:red|blue|green:匹配red或blue或green3.中括号[]:一个[]只匹配1位,[^]:排除[0-9]:匹配0-9之间的一个数字[^0-9]:排除0-9[a-z]:小写字母</div>
                    </li>
                    <li><a href="/article/1901329821254873088.htm"
                           title="uv:颠覆你的Python项目管理,速度提升10-100倍" target="_blank">uv:颠覆你的Python项目管理,速度提升10-100倍</a>
                        <span class="text-muted">强化学习曾小健2</span>
<a class="tag" taget="_blank" href="/search/uv/1.htm">uv</a><a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E5%BC%80%E5%8F%91%E8%AF%AD%E8%A8%80/1.htm">开发语言</a>
                        <div>uv:颠覆你的Python项目管理,速度提升10-100倍原创工业开源好项目工业开源好项目2025年01月05日00:01湖南Python生态系统繁荣的同时,也带来了一些挑战:繁多的包管理工具、缓慢的依赖安装速度、以及复杂的虚拟环境管理。面对这些问题,uv应运而生。它是一个用Rust编写的高性能Python包和项目管理器,旨在以更快的速度、更简洁的方式,解决Python开发中的诸多痛点。本文将详细</div>
                    </li>
                    <li><a href="/article/1901327554384556032.htm"
                           title="Python正则表达式(re模块)" target="_blank">Python正则表达式(re模块)</a>
                        <span class="text-muted">qq742234984</span>
<a class="tag" taget="_blank" href="/search/python/1.htm">python</a><a class="tag" taget="_blank" href="/search/%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F/1.htm">正则表达式</a><a class="tag" taget="_blank" href="/search/mysql/1.htm">mysql</a>
                        <div>Python正则表达式(re模块)概述正则表达式Python正则表达式re模块re.match方法常用的匹配规则-匹配字符常用的匹配规则-匹配字符数量常用的匹配规则-原生字符串常用的匹配规则-匹配开头结尾常用的匹配规则-分组匹配re.compile方法re.search方法re.findall方法re.sub方法re.split方法贪婪模式与非贪婪模式概述案例概述正则表达式英文名为RegularE</div>
                    </li>
                    <li><a href="/article/1901319110436909056.htm"
                           title="运维系列&Linux系列:Ubuntu安装登录lftp,并下载文件" target="_blank">运维系列&Linux系列:Ubuntu安装登录lftp,并下载文件</a>
                        <span class="text-muted">坦笑&&life</span>
<a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a><a class="tag" taget="_blank" href="/search/%E8%BF%90%E7%BB%B4/1.htm">运维</a><a class="tag" taget="_blank" href="/search/linux/1.htm">linux</a><a class="tag" taget="_blank" href="/search/ubuntu/1.htm">ubuntu</a>
                        <div>Ubuntu安装登录lftp,并下载文件Ubuntu安装登录lftp,并下载文件1.安装2.lftp连接此步骤可能报错:(1)ls:Fatalerror:Certificateverification:Nottrusted(1E:91:90:86:47:16:96:7D:12:C4:AC:3F:0F:04:98:C2:3C:78:A5:0C)(2)ls出现乱码3.cd到待下载的目录下Ubuntu安</div>
                    </li>
                    <li><a href="/article/1901313184623554560.htm"
                           title="AI技术学习笔记系列001:FastLanguageModel.get_peft_model 函数各参数的详细解释" target="_blank">AI技术学习笔记系列001:FastLanguageModel.get_peft_model 函数各参数的详细解释</a>
                        <span class="text-muted">新说一二</span>
<a class="tag" taget="_blank" href="/search/%E4%BA%BA%E5%B7%A5%E6%99%BA%E8%83%BD/1.htm">人工智能</a><a class="tag" taget="_blank" href="/search/%E5%AD%A6%E4%B9%A0/1.htm">学习</a><a class="tag" taget="_blank" href="/search/%E7%AC%94%E8%AE%B0/1.htm">笔记</a>
                        <div>以下是关于代码中FastLanguageModel.get_peft_model函数各参数的详细解释,以及企业实际微调时的选择考量:参数详解及对微调的影响1.r=32(秩)作用:控制LoRA适配器的低秩矩阵的维度(秩),直接影响可训练参数数量。影响:r越大:适配器表达能力更强,能捕捉更复杂的任务特征,但可能导致过拟合(尤其数据量少时),训练时间和显存占用增加。r越小:参数量少,训练更快,显存占用低</div>
                    </li>
                                <li><a href="/article/30.htm"
                                       title="Java实现的基于模板的网页结构化信息精准抽取组件:HtmlExtractor" target="_blank">Java实现的基于模板的网页结构化信息精准抽取组件:HtmlExtractor</a>
                                    <span class="text-muted">yangshangchuan</span>
<a class="tag" taget="_blank" href="/search/%E4%BF%A1%E6%81%AF%E6%8A%BD%E5%8F%96/1.htm">信息抽取</a><a class="tag" taget="_blank" href="/search/HtmlExtractor/1.htm">HtmlExtractor</a><a class="tag" taget="_blank" href="/search/%E7%B2%BE%E5%87%86%E6%8A%BD%E5%8F%96/1.htm">精准抽取</a><a class="tag" taget="_blank" href="/search/%E4%BF%A1%E6%81%AF%E9%87%87%E9%9B%86/1.htm">信息采集</a>
                                    <div>HtmlExtractor是一个Java实现的基于模板的网页结构化信息精准抽取组件,本身并不包含爬虫功能,但可被爬虫或其他程序调用以便更精准地对网页结构化信息进行抽取。 
   
HtmlExtractor是为大规模分布式环境设计的,采用主从架构,主节点负责维护抽取规则,从节点向主节点请求抽取规则,当抽取规则发生变化,主节点主动通知从节点,从而能实现抽取规则变化之后的实时动态生效。 
如</div>
                                </li>
                                <li><a href="/article/157.htm"
                                       title="java编程思想 -- 多态" target="_blank">java编程思想 -- 多态</a>
                                    <span class="text-muted">百合不是茶</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/%E5%A4%9A%E6%80%81%E8%AF%A6%E8%A7%A3/1.htm">多态详解</a>
                                    <div>一: 向上转型和向下转型 
面向对象中的转型只会发生在有继承关系的子类和父类中(接口的实现也包括在这里)。父类:人    子类:男人向上转型: Person p = new Man() ; //向上转型不需要强制类型转化向下转型: Man man =</div>
                                </li>
                                <li><a href="/article/284.htm"
                                       title="[自动数据处理]稳扎稳打,逐步形成自有ADP系统体系" target="_blank">[自动数据处理]稳扎稳打,逐步形成自有ADP系统体系</a>
                                    <span class="text-muted">comsci</span>
<a class="tag" taget="_blank" href="/search/dp/1.htm">dp</a>
                                    <div> 
      对于国内的IT行业来讲,虽然我们已经有了"两弹一星",在局部领域形成了自己独有的技术特征,并初步摆脱了国外的控制...但是前面的路还很长.... 
 
      首先是我们的自动数据处理系统还无法处理很多高级工程...中等规模的拓扑分析系统也没有完成,更加复杂的</div>
                                </li>
                                <li><a href="/article/411.htm"
                                       title="storm 自定义 日志文件" target="_blank">storm 自定义 日志文件</a>
                                    <span class="text-muted">商人shang</span>
<a class="tag" taget="_blank" href="/search/storm/1.htm">storm</a><a class="tag" taget="_blank" href="/search/cluster/1.htm">cluster</a><a class="tag" taget="_blank" href="/search/logback/1.htm">logback</a>
                                    <div>Storm中的日志级级别默认为INFO,并且,日志文件是根据worker号来进行区分的,这样,同一个log文件中的信息不一定是一个业务的,这样就会有以下两个需求出现: 
1. 想要进行一些调试信息的输出 
2. 调试信息或者业务日志信息想要输出到一些固定的文件中 
  
不要怕,不要烦恼,其实Storm已经提供了这样的支持,可以通过自定义logback 下的 cluster.xml 来输</div>
                                </li>
                                <li><a href="/article/538.htm"
                                       title="Extjs3 SpringMVC使用 @RequestBody 标签问题记录" target="_blank">Extjs3 SpringMVC使用 @RequestBody 标签问题记录</a>
                                    <span class="text-muted">21jhf</span>

                                    <div>springMVC使用 @RequestBody(required = false) UserVO userInfo 
传递json对象数据,往往会出现http 415,400,500等错误,总结一下需要使用ajax提交json数据才行,ajax提交使用proxy,参数为jsonData,不能为params;另外,需要设置Content-type属性为json,代码如下: 
(由于使用了父类aaa</div>
                                </li>
                                <li><a href="/article/665.htm"
                                       title="一些排错方法" target="_blank">一些排错方法</a>
                                    <span class="text-muted">文强chu</span>
<a class="tag" taget="_blank" href="/search/%E6%96%B9%E6%B3%95/1.htm">方法</a>
                                    <div>1、java.lang.IllegalStateException: Class invariant violation 
at org.apache.log4j.LogManager.getLoggerRepository(LogManager.java:199)at org.apache.log4j.LogManager.getLogger(LogManager.java:228) 
at o</div>
                                </li>
                                <li><a href="/article/792.htm"
                                       title="Swing中文件恢复我觉得很难" target="_blank">Swing中文件恢复我觉得很难</a>
                                    <span class="text-muted">小桔子</span>
<a class="tag" taget="_blank" href="/search/swing/1.htm">swing</a>
                                    <div>       我那个草了!老大怎么回事,怎么做项目评估的?只会说相信你可以做的,试一下,有的是时间! 
       用java开发一个图文处理工具,类似word,任意位置插入、拖动、删除图片以及文本等。文本框、流程图等,数据保存数据库,其余可保存pdf格式。ok,姐姐千辛万苦,</div>
                                </li>
                                <li><a href="/article/919.htm"
                                       title="php 文件操作" target="_blank">php 文件操作</a>
                                    <span class="text-muted">aichenglong</span>
<a class="tag" taget="_blank" href="/search/PHP/1.htm">PHP</a><a class="tag" taget="_blank" href="/search/%E8%AF%BB%E5%8F%96%E6%96%87%E4%BB%B6/1.htm">读取文件</a><a class="tag" taget="_blank" href="/search/%E5%86%99%E5%85%A5%E6%96%87%E4%BB%B6/1.htm">写入文件</a>
                                    <div>1 写入文件 
@$fp=fopen("$DOCUMENT_ROOT/order.txt", "ab"); 
if(!$fp){ 
 echo "open file error" ; 
 
exit; 
} 
$outputstring="date:"." \t tire:".$tire."</div>
                                </li>
                                <li><a href="/article/1046.htm"
                                       title="MySQL的btree索引和hash索引的区别" target="_blank">MySQL的btree索引和hash索引的区别</a>
                                    <span class="text-muted">AILIKES</span>
<a class="tag" taget="_blank" href="/search/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84/1.htm">数据结构</a><a class="tag" taget="_blank" href="/search/mysql/1.htm">mysql</a><a class="tag" taget="_blank" href="/search/%E7%AE%97%E6%B3%95/1.htm">算法</a>
                                    <div>Hash 索引结构的特殊性,其 检索效率非常高,索引的检索可以一次定位,不像B-Tree 索引需要从根节点到枝节点,最后才能访问到页节点这样多次的IO访问,所以 Hash 索引的查询效率要远高于 B-Tree 索引。           
可能很多人又有疑问了,既然 Hash 索引的效率要比 B-Tree 高很多,为什么大家不都用 Hash 索引而还要使用 B-Tree 索引呢</div>
                                </li>
                                <li><a href="/article/1173.htm"
                                       title="JAVA的抽象--- 接口 --实现" target="_blank">JAVA的抽象--- 接口 --实现</a>
                                    <span class="text-muted">百合不是茶</span>

                                    <div>抽象 接口 实现接口 
  
//抽象 类 ,方法 
  
//定义一个公共抽象的类 ,并在类中定义一个抽象的方法体 
抽象的定义使用abstract 
  
abstract class A 定义一个抽象类 例如: 
//定义一个基类
public abstract class A{ 
  
  
//抽象类不能用来实例化,只能用来继承 
//</div>
                                </li>
                                <li><a href="/article/1300.htm"
                                       title="JS变量作用域实例" target="_blank">JS变量作用域实例</a>
                                    <span class="text-muted">bijian1013</span>
<a class="tag" taget="_blank" href="/search/%E4%BD%9C%E7%94%A8%E5%9F%9F/1.htm">作用域</a>
                                    <div><script> 
    var scope='hello'; 
    function a(){ 
       console.log(scope);   //undefined 
       var scope='world'; 
       console.log(scope);   //world 
       console.log(b);      </div>
                                </li>
                                <li><a href="/article/1427.htm"
                                       title="TDD实践(二)" target="_blank">TDD实践(二)</a>
                                    <span class="text-muted">bijian1013</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/TDD/1.htm">TDD</a>
                                    <div>实践题目:分解质因数 
Step1: 
单元测试: 
package com.bijian.study.factor.test;

import java.util.Arrays;

import junit.framework.Assert;

import org.junit.Before;
import org.junit.Test;

import com.bijian.</div>
                                </li>
                                <li><a href="/article/1554.htm"
                                       title="[MongoDB学习笔记一]MongoDB主从复制" target="_blank">[MongoDB学习笔记一]MongoDB主从复制</a>
                                    <span class="text-muted">bit1129</span>
<a class="tag" taget="_blank" href="/search/mongodb/1.htm">mongodb</a>
                                    <div>MongoDB称为分布式数据库,主要原因是1.基于副本集的数据备份, 2.基于切片的数据扩容。副本集解决数据的读写性能问题,切片解决了MongoDB的数据扩容问题。 
  事实上,MongoDB提供了主从复制和副本复制两种备份方式,在MongoDB的主从复制和副本复制集群环境中,只有一台作为主服务器,另外一台或者多台服务器作为从服务器。   本文介绍MongoDB的主从复制模式,需要指明</div>
                                </li>
                                <li><a href="/article/1681.htm"
                                       title="【HBase五】Java API操作HBase" target="_blank">【HBase五】Java API操作HBase</a>
                                    <span class="text-muted">bit1129</span>
<a class="tag" taget="_blank" href="/search/hbase/1.htm">hbase</a>
                                    <div>import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HBaseConfiguration;
import org.apache.hadoop.hbase.HColumnDescriptor;
import org.apache.ha</div>
                                </li>
                                <li><a href="/article/1808.htm"
                                       title="python调用zabbix api接口实时展示数据" target="_blank">python调用zabbix api接口实时展示数据</a>
                                    <span class="text-muted">ronin47</span>

                                    <div>zabbix api接口来进行展示。经过思考之后,计划获取如下内容:     1、  获得认证密钥     2、  获取zabbix所有的主机组     3、  获取单个组下的所有主机     4、  获取某个主机下的所有监控项  </div>
                                </li>
                                <li><a href="/article/1935.htm"
                                       title="jsp取得绝对路径" target="_blank">jsp取得绝对路径</a>
                                    <span class="text-muted">byalias</span>
<a class="tag" taget="_blank" href="/search/%E7%BB%9D%E5%AF%B9%E8%B7%AF%E5%BE%84/1.htm">绝对路径</a>
                                    <div>在JavaWeb开发中,常使用绝对路径的方式来引入JavaScript和CSS文件,这样可以避免因为目录变动导致引入文件找不到的情况,常用的做法如下: 
 
一、使用${pageContext.request.contextPath} 
 
  代码” ${pageContext.request.contextPath}”的作用是取出部署的应用程序名,这样不管如何部署,所用路径都是正确的。 
 
</div>
                                </li>
                                <li><a href="/article/2062.htm"
                                       title="Java定时任务调度:用ExecutorService取代Timer" target="_blank">Java定时任务调度:用ExecutorService取代Timer</a>
                                    <span class="text-muted">bylijinnan</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a>
                                    <div>《Java并发编程实战》一书提到的用ExecutorService取代Java Timer有几个理由,我认为其中最重要的理由是: 
如果TimerTask抛出未检查的异常,Timer将会产生无法预料的行为。Timer线程并不捕获异常,所以 TimerTask抛出的未检查的异常会终止timer线程。这种情况下,Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时,已经被</div>
                                </li>
                                <li><a href="/article/2189.htm"
                                       title="SQL 优化原则" target="_blank">SQL 优化原则</a>
                                    <span class="text-muted">chicony</span>
<a class="tag" taget="_blank" href="/search/sql/1.htm">sql</a>
                                    <div>  
一、问题的提出 
 在应用系统开发初期,由于开发数据库数据比较少,对于查询SQL语句,复杂视图的的编写等体会不出SQL语句各种写法的性能优劣,但是如果将应用系统提交实际应用后,随着数据库中数据的增加,系统的响应速度就成为目前系统需要解决的最主要的问题之一。系统优化中一个很重要的方面就是SQL语句的优化。对于海量数据,劣质SQL语句和优质SQL语句之间的速度差别可以达到上百倍,可见对于一个系统</div>
                                </li>
                                <li><a href="/article/2316.htm"
                                       title="java 线程弹球小游戏" target="_blank">java 线程弹球小游戏</a>
                                    <span class="text-muted">CrazyMizzz</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/%E6%B8%B8%E6%88%8F/1.htm">游戏</a>
                                    <div>最近java学到线程,于是做了一个线程弹球的小游戏,不过还没完善 
 
 这里是提纲 
 1.线程弹球游戏实现 
 1.实现界面需要使用哪些API类 
 JFrame 
 JPanel 
 JButton 
 FlowLayout 
 Graphics2D 
 Thread 
 Color 
 ActionListener 
 ActionEvent 
 MouseListener 
 Mouse</div>
                                </li>
                                <li><a href="/article/2443.htm"
                                       title="hadoop jps出现process information unavailable提示解决办法" target="_blank">hadoop jps出现process information unavailable提示解决办法</a>
                                    <span class="text-muted">daizj</span>
<a class="tag" taget="_blank" href="/search/hadoop/1.htm">hadoop</a><a class="tag" taget="_blank" href="/search/jps/1.htm">jps</a>
                                    <div>hadoop jps出现process information unavailable提示解决办法       
jps时出现如下信息: 
3019 -- process information unavailable3053 -- process information unavailable2985 -- process information unavailable2917 -- </div>
                                </li>
                                <li><a href="/article/2570.htm"
                                       title="PHP图片水印缩放类实现" target="_blank">PHP图片水印缩放类实现</a>
                                    <span class="text-muted">dcj3sjt126com</span>
<a class="tag" taget="_blank" href="/search/PHP/1.htm">PHP</a>
                                    <div>  
<?php
class Image{

	private $path;


	function __construct($path='./'){
		$this->path=rtrim($path,'/').'/';
	}

	//水印函数,参数:背景图,水印图,位置,前缀,TMD透明度

	public function water($b,$l,$pos</div>
                                </li>
                                <li><a href="/article/2697.htm"
                                       title="IOS控件学习:UILabel常用属性与用法" target="_blank">IOS控件学习:UILabel常用属性与用法</a>
                                    <span class="text-muted">dcj3sjt126com</span>
<a class="tag" taget="_blank" href="/search/ios/1.htm">ios</a><a class="tag" taget="_blank" href="/search/UILabel/1.htm">UILabel</a>
                                    <div>参考网站: 
http://shijue.me/show_text/521c396a8ddf876566000007 
http://www.tuicool.com/articles/zquENb 
http://blog.csdn.net/a451493485/article/details/9454695 
http://wiki.eoe.cn/page/iOS_pptl_artile_281</div>
                                </li>
                                <li><a href="/article/2824.htm"
                                       title="完全手动建立maven骨架" target="_blank">完全手动建立maven骨架</a>
                                    <span class="text-muted">eksliang</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/eclipse/1.htm">eclipse</a><a class="tag" taget="_blank" href="/search/Web/1.htm">Web</a>
                                    <div>建一个 JAVA 项目 : 
mvn archetype:create 
-DgroupId=com.demo 
-DartifactId=App 
[-Dversion=0.0.1-SNAPSHOT] 
[-Dpackaging=jar] 
 
 
建一个 web 项目 : 
mvn archetype:create 
-DgroupId=com.demo 
-DartifactId=web-a</div>
                                </li>
                                <li><a href="/article/2951.htm"
                                       title="配置清单" target="_blank">配置清单</a>
                                    <span class="text-muted">gengzg</span>
<a class="tag" taget="_blank" href="/search/%E9%85%8D%E7%BD%AE/1.htm">配置</a>
                                    <div>1、修改grub启动的内核版本
vi /boot/grub/grub.conf
将default 0改为1

拷贝mt7601Usta.ko到/lib文件夹

拷贝RT2870STA.dat到 /etc/Wireless/RT2870STA/文件夹

拷贝wifiscan到bin文件夹,chmod 775 /bin/wifiscan
拷贝wifiget.sh到bin文件夹,chm</div>
                                </li>
                                <li><a href="/article/3078.htm"
                                       title="Windows端口被占用处理方法" target="_blank">Windows端口被占用处理方法</a>
                                    <span class="text-muted">huqiji</span>
<a class="tag" taget="_blank" href="/search/windows/1.htm">windows</a>
                                    <div>以下文章主要以80端口号为例,如果想知道其他的端口号也可以使用该方法..........................1、在windows下如何查看80端口占用情况?是被哪个进程占用?如何终止等.        这里主要是用到windows下的DOS工具,点击"开始"--"运行",输入&</div>
                                </li>
                                <li><a href="/article/3205.htm"
                                       title="开源ckplayer 网页播放器, 跨平台(html5, mobile),flv, f4v, mp4, rtmp协议. webm, ogg, m3u8 !" target="_blank">开源ckplayer 网页播放器, 跨平台(html5, mobile),flv, f4v, mp4, rtmp协议. webm, ogg, m3u8 !</a>
                                    <span class="text-muted">天梯梦</span>
<a class="tag" taget="_blank" href="/search/mobile/1.htm">mobile</a>
                                    <div>CKplayer,其全称为超酷flv播放器,它是一款用于网页上播放视频的软件,支持的格式有:http协议上的flv,f4v,mp4格式,同时支持rtmp视频流格 式播放,此播放器的特点在于用户可以自己定义播放器的风格,诸如播放/暂停按钮,静音按钮,全屏按钮都是以外部图片接口形式调用,用户根据自己的需要制作 出播放器风格所需要使用的各个按钮图片然后替换掉原始风格里相应的图片就可以制作出自己的风格了,</div>
                                </li>
                                <li><a href="/article/3332.htm"
                                       title="简单工厂设计模式" target="_blank">简单工厂设计模式</a>
                                    <span class="text-muted">hm4123660</span>
<a class="tag" taget="_blank" href="/search/java/1.htm">java</a><a class="tag" taget="_blank" href="/search/%E5%B7%A5%E5%8E%82%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/1.htm">工厂设计模式</a><a class="tag" taget="_blank" href="/search/%E7%AE%80%E5%8D%95%E5%B7%A5%E5%8E%82%E6%A8%A1%E5%BC%8F/1.htm">简单工厂模式</a>
                                    <div>       简单工厂模式(Simple Factory Pattern)属于类的创新型模式,又叫静态工厂方法模式。是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。 </div>
                                </li>
                                <li><a href="/article/3459.htm"
                                       title="maven笔记" target="_blank">maven笔记</a>
                                    <span class="text-muted">zhb8015</span>
<a class="tag" taget="_blank" href="/search/maven/1.htm">maven</a>
                                    <div>跳过测试阶段: 
mvn package -DskipTests 
临时性跳过测试代码的编译: 
mvn package -Dmaven.test.skip=true 
  
maven.test.skip同时控制maven-compiler-plugin和maven-surefire-plugin两个插件的行为,即跳过编译,又跳过测试。 
  
指定测试类 
mvn test</div>
                                </li>
                                <li><a href="/article/3586.htm"
                                       title="非mapreduce生成Hfile,然后导入hbase当中" target="_blank">非mapreduce生成Hfile,然后导入hbase当中</a>
                                    <span class="text-muted">Stark_Summer</span>
<a class="tag" taget="_blank" href="/search/map/1.htm">map</a><a class="tag" taget="_blank" href="/search/hbase/1.htm">hbase</a><a class="tag" taget="_blank" href="/search/reduce/1.htm">reduce</a><a class="tag" taget="_blank" href="/search/Hfile/1.htm">Hfile</a><a class="tag" taget="_blank" href="/search/path%E5%AE%9E%E4%BE%8B/1.htm">path实例</a>
                                    <div>最近一个群友的boss让研究hbase,让hbase的入库速度达到5w+/s,这可愁死了,4台个人电脑组成的集群,多线程入库调了好久,速度也才1w左右,都没有达到理想的那种速度,然后就想到了这种方式,但是网上多是用mapreduce来实现入库,而现在的需求是实时入库,不生成文件了,所以就只能自己用代码实现了,但是网上查了很多资料都没有查到,最后在一个网友的指引下,看了源码,最后找到了生成Hfile</div>
                                </li>
                                <li><a href="/article/3713.htm"
                                       title="jsp web tomcat 编码问题" target="_blank">jsp web tomcat 编码问题</a>
                                    <span class="text-muted">王新春</span>
<a class="tag" taget="_blank" href="/search/tomcat/1.htm">tomcat</a><a class="tag" taget="_blank" href="/search/jsp/1.htm">jsp</a><a class="tag" taget="_blank" href="/search/pageEncode/1.htm">pageEncode</a>
                                    <div>今天配置jsp项目在tomcat上,windows上正常,而linux上显示乱码,最后定位原因为tomcat 的server.xml 文件的配置,添加 URIEncoding 属性: 
 
 

      <Connector port="8080" protocol="HTTP/1.1" 
               connectionTi</div>
                                </li>
                </ul>
            </div>
        </div>
    </div>

<div>
    <div class="container">
        <div class="indexes">
            <strong>按字母分类:</strong>
            <a href="/tags/A/1.htm" target="_blank">A</a><a href="/tags/B/1.htm" target="_blank">B</a><a href="/tags/C/1.htm" target="_blank">C</a><a
                href="/tags/D/1.htm" target="_blank">D</a><a href="/tags/E/1.htm" target="_blank">E</a><a href="/tags/F/1.htm" target="_blank">F</a><a
                href="/tags/G/1.htm" target="_blank">G</a><a href="/tags/H/1.htm" target="_blank">H</a><a href="/tags/I/1.htm" target="_blank">I</a><a
                href="/tags/J/1.htm" target="_blank">J</a><a href="/tags/K/1.htm" target="_blank">K</a><a href="/tags/L/1.htm" target="_blank">L</a><a
                href="/tags/M/1.htm" target="_blank">M</a><a href="/tags/N/1.htm" target="_blank">N</a><a href="/tags/O/1.htm" target="_blank">O</a><a
                href="/tags/P/1.htm" target="_blank">P</a><a href="/tags/Q/1.htm" target="_blank">Q</a><a href="/tags/R/1.htm" target="_blank">R</a><a
                href="/tags/S/1.htm" target="_blank">S</a><a href="/tags/T/1.htm" target="_blank">T</a><a href="/tags/U/1.htm" target="_blank">U</a><a
                href="/tags/V/1.htm" target="_blank">V</a><a href="/tags/W/1.htm" target="_blank">W</a><a href="/tags/X/1.htm" target="_blank">X</a><a
                href="/tags/Y/1.htm" target="_blank">Y</a><a href="/tags/Z/1.htm" target="_blank">Z</a><a href="/tags/0/1.htm" target="_blank">其他</a>
        </div>
    </div>
</div>
<footer id="footer" class="mb30 mt30">
    <div class="container">
        <div class="footBglm">
            <a target="_blank" href="/">首页</a> -
            <a target="_blank" href="/custom/about.htm">关于我们</a> -
            <a target="_blank" href="/search/Java/1.htm">站内搜索</a> -
            <a target="_blank" href="/sitemap.txt">Sitemap</a> -
            <a target="_blank" href="/custom/delete.htm">侵权投诉</a>
        </div>
        <div class="copyright">版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.
<!--            <a href="https://beian.miit.gov.cn/" rel="nofollow" target="_blank">京ICP备09083238号</a><br>-->
        </div>
    </div>
</footer>
<!-- 代码高亮 -->
<script type="text/javascript" src="/static/syntaxhighlighter/scripts/shCore.js"></script>
<script type="text/javascript" src="/static/syntaxhighlighter/scripts/shLegacy.js"></script>
<script type="text/javascript" src="/static/syntaxhighlighter/scripts/shAutoloader.js"></script>
<link type="text/css" rel="stylesheet" href="/static/syntaxhighlighter/styles/shCoreDefault.css"/>
<script type="text/javascript" src="/static/syntaxhighlighter/src/my_start_1.js"></script>





</body>

</html><script data-cfasync="false" src="/cdn-cgi/scripts/5c5dd728/cloudflare-static/email-decode.min.js"></script>