目录

• • 引言
  • 仓颉正则的构造函数
  • • 1. 基本构造函数
    • 2. 带选项的构造函数
    • 3. 常用正则选项
  • 仓颉中正则的规则
  • 仓颉中正则的使用
  • • 1. 使用matchs函数判断是否正则规则
    • 2. 使用find查找第一个匹配字符
    • 3. 使用findAll查找所有匹配字符
    • 4.仓颉中正则命名捕获组和映射
    • • 语法
      • 参数
      • 示例解析
    • 5.扩展知识点

引言

正则表达式是处理字符串的强大工具，在给类编程语言中有着广泛的应用，本文将全面介绍正则表达式在仓颉中的使用方法。

仓颉正则的构造函数

在仓颉语言中，正则表达式的构造函数是通过 Regex类实现的。

1. 基本构造函数

import std.regex.*

// 基本构造函数
let regex1 = Regex("\\d+")  // 匹配一个或多个数字
let regex2 = Regex("[A-Za-z]+")  // 匹配一个或多个字母

2. 带选项的构造函数

Regex构造函数支持可选的第二个参数来指定匹配选项：

let regex3 = Regex("^start", RegexFlag.MultiLine)  // 多行模式
let regex4 = Regex("case", RegexFlag.IgnoreCase)  // 忽略大小写

3. 常用正则选项

RegexFlag枚举包含以下常用选项：

• IgnoreCase：忽略大小写
• MultiLine：多行模式（^和$匹配每行的开头和结尾）
• Unicode：启用Unicode感知的大小写折叠

仓颉中正则的规则

当前仓颉的正则表达式仅支持以下规则，使用不支持的规则会导致输出结果与预期不符。

字符	描述
\	将下一个字符标记为一个特殊字符（File Format Escape，清单见本表）、或一个原义字符（Identity Escape，有^$()*+?.[{|共计 12 个)、或一个向后引用(backreferences)。例如，“n”匹配字符“n”。\n匹配一个换行符。序列\匹配\，而(则匹配(。
^	匹配输入字符串的开始位置。如果设置了 RegexOption 中的多行模式 multiLine()，^也匹配\n或\r之后的位置。
$	匹配输入字符串的结束位置。
*	匹配前面的子表达式零次或多次。例如，zo*能匹配z、zo以及zoo。*等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，zo+能匹配zo以及zoo，但不能匹配z。+等价于{1,}。
?	匹配前面的子表达式零次或一次。例如，do(es)?可以匹配does中的do和does。?等价于{0,1}。
{n}	n 是一个非负整数。匹配确定的 n 次。例如，o{2}不能匹配Bob中的o，但是能匹配food中的两个o。
{n,}	n 是一个非负整数。至少匹配 n 次。例如，o{2,}不能匹配Bob中的o，但能匹配foooood中的所有o。o{1,}等价于o+。o{0,}则等价于o*。
{n,m}	m 和 n 均为非负整数，其中 n<=m。最少匹配 n 次且最多匹配 m 次。例如，o{1,3}将匹配fooooood中的前三个o。o{0,1}等价于o?。请注意在逗号和两个数之间不能有空格。
?	非贪心量化（Non-greedy quantifiers）：当该字符紧跟在任何一个其他重复修饰符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串oooo，o+?将匹配单个o，而o+将匹配所有o。
.	匹配除\n之外的任何单个字符。要匹配包括\n在内的任何字符，请使用像(.|\n)的模式。
(pattern)	匹配 pattern 并获取这一匹配的子字符串。该子字符串用于向后引用。所获取的匹配可以从产生的 Matches 集合中得到。要匹配圆括号字符，请使用\(或\)。可带数量后缀。
x|y	没有包围在()里，其范围是整个正则表达式。例如，z|food 能匹配z或food。(?😒
[xyz]	字符集合（character class）。匹配所包含的任意一个字符。例如，[abc]可以匹配plain中的a。特殊字符仅有反斜线\保持特殊含义，用于转义字符。其他特殊字符如星号、加号、各种括号等均作为普通字符。脱字符^如果出现在首位则表示负值字符集合；如果出现在字符串中间就仅作为普通字符。连字符 - 如果出现在字符串中间表示字符范围描述；如果如果出现在首位（或末尾）则仅作为普通字符。右方括号应转义出现，也可以作为首位字符出现。
[^xyz]	排除型字符集合（negated character classes）。匹配未列出的任意字符。例如，[^abc]可以匹配plain中的plin。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，[a-z]可以匹配a到z范围内的任意小写字母字符。
[^a-z]	排除型的字符范围。匹配任何不在指定范围内的任意字符。例如，[^a-z]可以匹配任何不在a到z范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如，er\b可以匹配never中的er，但不能匹配verb中的er。
\B	匹配非单词边界。er\B能匹配verb中的er，但不能匹配never中的er。
\d	匹配一个数字字符。等价于[0-9]。
\D	匹配一个非数字字符。等价于[^0-9]。
\f	匹配一个换页符。等价于\x0c。
\n	匹配一个换行符。等价于\x0a。
\r	匹配一个回车符。等价于\x0d。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于[\f\n\r\t\v]。
\S	匹配任何非空白字符。等价于[^\f\n\r\t\v]。
\t	匹配一个制表符。等价于\x09。
\v	匹配\n\v\f\r\x85。
\w	匹配包括下划线的任何单词字符。等价于[A-Za-z0-9_]。
\W	匹配任何非单词字符。等价于[^A-Za-z0-9_]。
\xnm	十六进制转义字符序列。匹配两个十六进制数字 nm 表示的字符。例如，\x41匹配A。正则表达式中可以使用 ASCII 码。
\num	向后引用（back-reference）一个子字符串（substring），该子字符串与正则表达式的第 num 个用括号围起来的捕捉群（capture group）子表达式（subexpression）匹配。其中 num 是从 1 开始的十进制正整数，Regex 捕获组上限为 63。例如：(.)\1匹配两个连续的相同字符。
(?:pattern)	匹配 pattern 但不获取匹配的子字符串（shy groups），也就是说这是一个非获取匹配，不存储匹配的子字符串用于向后引用。这在使用或字符(|)来组合一个模式的各个部分是很有用。
(?=pattern)	正向肯定预查（look ahead positive assert），在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，Windows(?=95|98|NT|2000)能匹配Windows2000中的Windows，但不能匹配Windows3.1中的Windows。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	正向否定预查（negative assert），在任何不匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如Windows(?!95|98|NT|2000)能匹配Windows3.1中的Windows，但不能匹配Windows2000中的Windows。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?<=pattern)	反向（look behind）肯定预查，与正向肯定预查类似，只是方向相反。例如，(?<=95|98|NT|2000)Windows能匹配2000Windows中的Windows，但不能匹配3.1Windows中的Windows。
(?<!pattern)	反向否定预查，与正向否定预查类似，只是方向相反。例如(?<!95|98|NT|2000)Windows能匹配3.1Windows中的Windows，但不能匹配2000Windows中的Windows。
(?i)	通过规则指定部分规则忽略大小写。当前 Regex 仅支持全局忽略大小写，当该选项被指定时，会被当做全局忽略大小写对待。
(?-i)	通过规则指定部分规则大小写敏感。 当前 Regex 默认大小写敏感，该选项仅做编译兼容处理，不做敏感处理。
+	单独一个加号，不是转义的\+。
*	单独一个星号，不是转义的\*。
-	单独一个减号，不是转义的\-。
]	单独一个右中括号，不是转义的\]。
}	单独一个右大括号，不是转义的\}。
[[:alpha:]]	表示任意大小写字母。
[[:^alpha:]]	表示除大小写字母以外的任意字符。
[[:lower:]]	表示任意小写字母。
[[:^lower:]]	表示除小写字母以外的任意字符。
[[:upper:]]	表示任意大写字母。
[[:^upper:]]	表示除大写字母以外的任意字符。
[[:digit:]]	表示0到9之间的任意单个数字。
[[:^digit:]]	表示除0到9之间的单个数字以外的任意字符。
[[:xdigit:]]	表示十六进制的字母和数字。
[[:^xdigit:]]	表示除十六进制的字母和数字以外的任意字符。
[[:alnum:]]	表示任意数字或字母。
[[:^alnum:]]	表示除数字或字母以外的任意字符。
[[:space:]]	表示任意空白字符，包括"空格"、"tab键"等。
[[:^space:]]	表示除空白字符以外的任意字符。
[[:punct:]]	表示任意标点符号。
[[:^punct:]]	表示除任意标点符号以外的任意字符。

在仓颉中，还存在一些特殊的规则：

1. ?、+、* 前面的字符不可量化时，会被忽略；特例：(*、|*、* 开头时 * 会被视为普通字符。
2. *? 在匹配全部 *? 之前的字符组成的字符串时，会匹配不到该字符。
3. 正则表达式的捕获组的最大个数为 63，编译后的最大规则长度为 65535。
4. 暂不支持的场景：((pattern1){m1,n1}pattern2){m2,n2}，即：
   • 组定义 1 被{m1,n1}修饰；
   • 组定义 1 被组定义 2 包裹；
   • 组定义 2 被{m2,n2}修饰。
5. 待匹配字符串需要用户自行保障不包含 \0，否则会得到预期以外的结果，甚至会陷入死循环无法退出。

警告：

当前实现中未对规则为{n}、{n,}、{n,m}创建的最小或者最大重复次数进行限制，重复次数过大会造成创建正则匹配器时占用大量的CPU和内存资源，甚至会触发栈溢出异常退出，从而导致执行时间过长或者 ReDos攻击。

仓颉中正则的使用

1. 使用matchs函数判断是否正则规则

import std.regex.*

let text = "2023-10-05"
let regex = Regex("(\\d{4})-(\\d{2})-(\\d{2})")
println(regex.matches(text)) // true

2. 使用find查找第一个匹配字符

import std.regex.*

let regex = Regex("hello")
match (r2.find("hello world")) {
    case Some(r) => println(r.matchString()) // hello
    case None => println("None") // None
}

3. 使用findAll查找所有匹配字符

在仓颉中，findAll用于获取字符序列中所有符合条件的字符并以数组方式进行返回，如果需要获取具体的字符信息，我们需要结合迭代器iterator进行使用，然后通过matchString转为具体字符串

import std.regex.*

let r = Regex("ab")
let arr = r.findAll("ababaaab")
let iter = arr.iterator()
println(arr.size)
while (true) {
   match (iter.next()) {
       case Some(i) => println(i.matchString())
       case None => break
   }
}

4.仓颉中正则命名捕获组和映射

命名捕获组是一种特殊的捕获组，它允许为组指定一个名称。组的匹配结果可以通过这个名称而不是它在模式中的索引来标识。命名捕获组可以像常规捕获组一样使用——它们在结果数组中也有它们的匹配索引，并且可以通过\1、\2等引用。唯一的区别是它们可以额外地通过它们的名称引用。所有名称在同一模式内必须是唯一的。具有相同名称的多个命名捕获组会导致语法错误。

语法

(?<name>pattern)

参数

pattern此模式可以包含任何可在正则表达式字面量中使用的内容，包括或运算符。

name组的名称。必须是有效的标识符

示例解析

(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})

在以上的正则表达式中存在三个命名捕获组，分别为year month day，当我们字符串为2024-10-24&2025-01-01时，我们可以获取到两个捕获组，在仓颉中捕获组是以Map对象返回的，示例代码如下：

import std.regex.*

let r = Regex(#"(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})"#)
let arr = r.findAll("2024-10-24&2025-01-01", group: true)

// 遍历捕获组
for (md in arr) {
    println("# found: `${md.matchString()}` and groupCount: ${md.groupCount()}")
    // 输出
    for ((name, index) in r.getNamedGroups()) {
        println("${name} => ${index}")
    }
}

运行结果：

# found: `2024-10-24` and groupCount: 3
day => 3
month => 2
year => 1
# found: `2025-01-01` and groupCount: 3
day => 3
month => 2
year => 1

5.扩展知识点

在仓颉中，正则表达式有两种书写方式，一种是结合转移字符，一种则是使用#对表达式文本进行包裹，当我们使用#时转移字符\d是不需要再通过\进行转义，示例如下:

#"(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})"#

"(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})"

以上两种书写方式最终结果是一致的