RE（正则表达式）

正则表达式（Regular Expression，简称为 “regex”）是一种用于处理字符串的强大工具，可以用来匹配、查找、替换和分割文本。在编程中，正则表达式广泛应用于文本处理和数据提取等场景。

通过在线工具（如 regex101 ↗）可以方便地测试和调试正则表达式。

1. 基本匹配

正则表达式是由字符和元字符组成的模式，用于描述字符串的一部分。字符就是普通的文本字符，例如 a、b、1 等；元字符具有特殊含义，用于表示某种模式。

1.1 字符匹配

在正则表达式中，大多数字符都与自身相匹配。例如，正则表达式 abc 匹配字符串 "abc"。

1.2 元字符

以下字符具有特殊含义，被称为元字符：

. ^ $ * + ? { } [ ] \ | ( )

要在正则表达式中匹配这些字符本身，需要在它们前面加上反斜线 \。

2. 字符类

字符类允许我们匹配一组字符中的任意一个。它由一对方括号 [ 和 ] 包围，其中包含要匹配的字符。

例如，正则表达式 [abc] 匹配字符 a、b 或 c。

2.1 范围

在字符类中，可以使用短横线 - 表示字符范围。例如，[a-z] 匹配任意小写字母；[0-9] 匹配任意数字。

2.2 预定义字符类

正则表达式提供了一些预定义的字符类：

\d：等价于 [0-9]，匹配任意数字。
\D：等价于 [^0-9]，匹配任意非数字字符。
\w：等价于 [a-zA-Z0-9_]，匹配任意字母、数字或下划线。
\W：等价于 [^a-zA-Z0-9_]，匹配任意非字母、数字或下划线的字符。
\s：匹配任意空白字符，如空格、制表符和换行符。
\S：匹配任意非空白字符。

3. 量词

量词指定一个模式出现的次数。常用的量词有：

*：匹配前面的模式 0 次或多次。
+：匹配前面的模式 1 次或多次。
?：匹配前面的模式 0 次或 1 次。
{n}：匹配前面的模式正好 n 次。
{n,}：匹配前面的模式至少 n 次。
{n,m}：匹配前面的模式至少 n 次，最多 m 次。

4. 分组和捕获

使用圆括号 ( 和 ) 可以将多个字符组合成一个分组。例如，正则表达式 (ab)+ 匹配字符串 "ab" 重复出现的部分，如 "ab"、"abab" 等。

分组还具有捕获功能，可以在匹配成功后提取分组中的内容。捕获的顺序是从左到右，按照左括号的顺序编号。

5. 断言

断言用于判断字符串的当前位置是否满足某个条件，但不消耗字符。常用的断言有：

^：匹配字符串的开始位置。
$：匹配字符串的结束位置。
\b：匹配单词的边界（即单词与空白字符之间的位置）。
\B：匹配非单词边界的位置。
(?=...)：正向先行断言，要求接下来的字符满足指定的模式，但不消耗字符。
(?!...)：负向先行断言，要求接下来的字符不满足指定的模式，但不消耗字符。

6. 使用正则表达式的语言功能

大多数编程语言都内置了对正则表达式的支持。以下是一些常见编程语言中使用正则表达式的示例：

6.1 C++

在 C++ 中，可以使用 <regex> 头文件中的正则表达式库来处理正则表达式。以下是一些常见的正则表达式库函数：

std::regex_search(str, pattern)：在字符串中查找指定模式的第一个匹配项。
std::regex_match(str, pattern)：检查字符串是否与指定模式完全匹配。
std::regex_replace(str, pattern, newStr)：将字符串中与指定模式匹配的项替换为指定的字符串。
std::regex_iterator：用于迭代查找字符串中所有与指定模式匹配的项。

示例：

#include <iostream>
#include <regex>
#include <string>

int main() {
  std::regex pattern("\\d+"); // 创建一个匹配数字的正则表达式模式
  std::string str = "Found 42 items, each costs $15";

  // 查找第一个匹配项
  std::smatch match;
  if (std::regex_search(str, match, pattern)) {
    std::cout << "First match: " << match[0] << "\n";
  }

  // 检查是否完全匹配
  if (std::regex_match(str, pattern)) {
    std::cout << "Matched completely\n";
  }

  // 查找所有匹配项
  std::sregex_iterator it(str.begin(), str.end(), pattern);
  std::sregex_iterator end;
  std::cout << "All matches: ";
  while (it != end) {
    std::cout << (*it)[0] << " ";
    ++it;
  }
  std::cout << "\n";

  // 替换匹配项
  std::string newStr = std::regex_replace(str, pattern, "NUMBER");
  std::cout << "New string: " << newStr << "\n";

  return 0;
}

6.2 Python

在 Python 中，可以使用 re 模块处理正则表达式。以下是一些常见的 re 模块函数：

re.search(pattern, string)：在字符串中查找指定模式的第一个匹配项。
re.findall(pattern, string)：返回字符串中所有与指定模式匹配的项的列表。
re.sub(pattern, repl, string, count=0)：将字符串中与指定模式匹配的项替换为指定的字符串，可限制替换次数。

示例：

import re

pattern = r'\d+'
string = 'Found 42 items, each costs $15'

# 查找第一个匹配项
match = re.search(pattern, string)
print(match.group())  # 输出：42

# 查找所有匹配项
numbers = re.findall(pattern, string)
print(numbers)  # 输出：['42', '15']

# 替换匹配项
new_string = re.sub(pattern, 'NUMBER', string)
print(new_string)  # 输出：Found NUMBER items, each costs $NUMBER

6.3 JavaScript

在 JavaScript 中，正则表达式可以使用 RegExp 对象表示。以下是一些常见的正则表达式方法：

regex.test(string)：测试字符串是否包含与正则表达式匹配的部分。
regex.exec(string)：在字符串中查找与正则表达式匹配的部分，返回一个匹配对象或 null。
string.match(regex)：返回一个数组，其中包含字符串中与正则表达式匹配的所有部分。
string.replace(regex, replacement)：将字符串中与正则表达式匹配的部分替换为指定的字符串。

示例：

const pattern = /\d+/;
const string = 'Found 42 items, each costs $15';

// 测试是否匹配
console.log(pattern.test(string));  // 输出：true

// 查找第一个匹配项
const match = pattern.exec(string);
console.log(match[0]);  // 输出：42

// 查找所有匹配项
const numbers = string.match(/\d+/g);
console.log(numbers);  // 输出：[ '42', '15' ]

// 替换匹配项
const newString = string.replace(pattern, 'NUMBER');
console.log(newString);  // 输出：Found NUMBER items, each costs $15