regex 包

介绍

该包使用正则表达式分析处理文本(仅支持 Ascii 编码字符串)，支持查找、分割、替换、验证等功能。

主要接口

class Regex

public class Regex {
    public init(s: String)
    public init(s: String, option: RegexOption)
}

Regex 用来指定编译类型和输入序列。

正则匹配规则详见 regex 规则集。

Regex 类提供的 API 如下所示：

init

public init(s: String)

功能：创建一个 Regex 实例， 匹配模式为普通模式。

参数：

  • s：正则表达式

异常：

  • RegexException：如果初始化失败，则抛异常
  • IllegalArgumentException：s 中包含空字符时，则抛出异常

init

public init(s: String, option: RegexOption)

功能：创建一个 Regex 实例。

参数：

  • s：正则表达式
  • option：当前有三种模式可选，分别是普通模式、忽略大小写模式和多行文本模式(忽略大小写模式和多行文本模式可同时支持)

异常：

  • RegexException：如果初始化失败，则抛异常
  • IllegalArgumentException：s 中包含空字符时，则抛出异常

func matcher

public func matcher(input: String): Matcher

功能：创建匹配器。

参数：

  • input：要匹配的字符串, 字符串长度最大2^31 - 1

返回值：返回创建的匹配器

异常：

  • RegexException：如果初始化失败，抛出异常
  • IllegalArgumentException：input 中包含空字符时，抛出异常

func matches

public func matches(input: String): Option<MatchData>

功能：创建匹配器，并将入参 input 与正则表达式进行完全匹配。

参数：

  • input：要匹配的字符串

返回值：匹配到结果，返回 Option，否则返回 Option.None

异常：

  • RegexException：如果初始化失败，抛出异常
  • IllegalArgumentException：input 中包含空字符时，抛出异常

func string

public func string(): String

功能：返回正则的输入序列。

返回值：返回输入序列

class Matcher

public class Matcher {
    public init(re: Regex, input: String)
}

Regex 的匹配器，用于扫描输入序列并进行匹配。

要匹配的字符串最大长度不得超过 2^31-1。

要使用 replaceAll 替换的字符串最大长度不得超过 2^30-2。

init

public init(re: Regex, input: String)

功能：创建一个 Matcher 实例。

参数：

  • re：正则表达式
  • input：要匹配的字符串

异常：

  • RegexException：如果初始化失败，则抛异常
  • IllegalArgumentException：input 中包含空字或长度大于2^31-1时，则抛出异常

func fullMatch

public func fullMatch(): Option<MatchData>

功能：对整个输入序列进行匹配。

返回值：全部匹配才会返回对应的 Option, 否则返回 Option.None

func matchStart

public func matchStart(): Option<MatchData>

功能：对输入序列的头部进行匹配。

返回值：匹配到结果返回 Option，如果匹配不到，返回 Option.None

异常：

  • RegexException：如果重置匹配器时内存分配失败，抛出异常

func allCount

public func allCount(): Int64

功能：获取匹配正则表示式的结果总数默认是从头到尾匹配的结果，使用了 setRegion 后只会在设置的范围内查找。

返回值：匹配结果总数

func find

public func find(): Option<MatchData>

功能：自当前字符串偏移位置起，返回匹配到的第一个子序列, find 调用一次，当前偏移位置为最新一次匹配到的子序列后第一个字符位置，再次调用, find 从当前位置开始匹配。

返回值：匹配到结果返回 Option，如果匹配不到，返回 Option.None

异常：

  • RegexException：如果重置匹配器时内存分配失败，抛出异常

func find

public func find(index: Int64): Option<MatchData>

功能：重置该匹配器索引位置，从 index 对应的位置处开始对输入序列进行匹配, 返回匹配到的子序列。

返回值：匹配到结果返回 Option，如果匹配不到，返回 Option.None

异常：

  • IndexOutOfBoundsException：如果 index 小于0，或 index 大于等于输入序列的 size ，则抛异常
  • RegexException：如果重置匹配器时内存分配失败，或匹配失败，抛出异常

func findAll

public func findAll(): Option<Array<MatchData>>

功能：对整个输入序列进行匹配, 找到所有匹配到的子序列生成一个包含所有可匹配子序列的Array，否则解构后为 None。

返回值：匹配到结果返回 Option<Array>，如果匹配不到，返回 Option<Array>.None

异常：

  • RegexException：如果获取失败，则抛异常
  • RegexException：如果重置匹配器时内存分配失败，抛出异常
  • RegexException：如果申请内存失败，抛出异常

func replace

public func replace(replacement: String): String

功能：自当前字符串偏移位置起，匹配到的第一个子序列替换为目标字符串, 并将当前索引位置设置到匹配子序列的下一个位置。返回替换后的字符串。 参数：

  • replacement：指定替换字符串

返回值：返回替换后字符串

异常：

  • RegexException：如果重置匹配器时内存分配失败，则抛出异常
  • IllegalArgumentException：如果 replacement 长度大于2^30-2，或者 replacement 包含空字符，则抛出异常

func replace

public func replace(replacement: String, index: Int64): String

功能：从输入序列的 Index 位置起匹配正则，将匹配到的第一个子序列替换为目标字符串，返回替换后的字符串。

参数：

  • replacement：指定替换字符串
  • index：匹配开始位置

返回值：返回替换后字符串

异常：

  • IndexOutOfBoundsException：如果index值不符合规定，则抛异常
  • RegexException：如果重置匹配器时内存分配失败，则抛出异常
  • IllegalArgumentException：如果 replacement 长度大于2^30-2，或者 replacement 包含空字符，则抛出异常

func replaceAll

public func replaceAll(replacement: String): String

功能：将输入序列中所有与正则匹配的子序列替换为给定的目标字符串，返回替换后的字符串。

参数：

  • replacement：指定替换字符串

返回值：String 是替换后的字符串

异常：

  • RegexException：如果重置匹配器时内存分配失败，或者 c 侧申请内存失败，或者替换字符串时发生了 GC，则抛出异常
  • IllegalArgumentException：如果 replacement 长度大于2^30-2，或者 replacement 包含空字符，则抛出异常

func replaceAll

public func replaceAll(replacement: String, limit: Int64): String

功能：将输入序列中与正则匹配的前 limit 个子序列替换为给定的替换字符串，返回替换后的字符串。

参数：

  • limit：替换次数. 如果 limit 等于 0, 返回原来的序列；如果 limit 为负数, 将尽可能多次的替换
  • replacement：指定替换字符串

返回值：返回替换后字符串

异常：

  • RegexException：如果重置匹配器时内存分配失败，或者 c 侧申请内存失败，或者替换字符串时发生了 GC，则抛出异常
  • IllegalArgumentException：如果 replacement 长度大于2^30-2，或者 replacement 包含空字符，则抛出异常

func split

public func split(): Array<String>

功能：将给定的输入序列根据正则尽可能的分割成多个子序列。

返回值：子序列数组

func split

public func split(limit: Int64): Array<String>

功能：将给定的输入序列根据正则尽可能的分割成多个子序列 (最多分割成 limit 个子串)。

参数：

  • limit：传入最多分割的子串个数

返回值：如果 limit>0, 返回最多 limit 个子串；如果 limit<=0, 返回最大可分割数个子串

异常：

  • RegexException：如果重置匹配器时内存分配失败，抛出异常

func setRegion

public func setRegion(beginIndex: Int64, endIndex: Int64): Matcher

功能：设置匹配器可搜索区域的位置信息，具体位置由指定的 begin 和 end 决定。

参数：

  • beginIndex：区域开始位置
  • endIndex：区域结束位置

返回值：返回匹配器自身

异常：

  • IndexOutOfBoundsException：如果 beginIndex 小于0，或 beginIndex 大于输入序列的 size ，则抛异常
  • IndexOutOfBoundsException：如果 endIndex 小于0，或 endIndex 大于输入序列的 size ，则抛异常
  • IndexOutOfBoundsException：如果 beginIndex 大于 endIndex ，则抛异常
  • RegexException：如果匹配失败，则抛异常

func region

public func region(): Position

功能：返回匹配器的区域设置。

返回值：返回匹配器的区域设置

func resetRegion

public func resetRegion(): Matcher

功能：重置匹配器开始位置和结束位置。

返回值：返回匹配器自身

异常：

  • RegexException：如果重置匹配器时内存分配失败，或匹配失败，则抛异常

func resetString

public func resetString(input: String): Matcher

功能：重设匹配序列，并重置匹配器。

参数：

  • input：要匹配的字符串

返回值：返回匹配器自身

异常：

  • RegexException：如果重置匹配器时内存分配失败，抛出异常
  • IllegalArgumentException：input 长度大于2^31-1时，则抛出异常

func getString

public func getString(): String

功能：获取要匹配的字符串。

返回值：返回匹配序列

class RegexOption

public class RegexOption <: ToString {
    public init()
}

RegexOption 类用于指定正则匹配的模式。默认的正则匹配算法为 NFA ，匹配运行次数上限为 1000000。 提供的 API 如下所示：

init

public init()

功能：创建一个 RegexOption 实例， 匹配模式为普通模式（NORMAL）。

func ignoreCase

public func ignoreCase(): RegexOption

功能：修改 RegexOption， 修改匹配模式为忽略大小写（IGNORECASE）。

返回值：返回修改后的 RegexOption

func multiLine

public func multiLine(): RegexOption

功能：修改 RegexOption， 修改匹配模式为多行文本模式（MULTILINE）。

返回值：返回修改后的 RegexOption

func toString

public func toString(): String

功能：获取 RegexOption 当前表示的正则匹配模式。

返回值：返回正则匹配模式

class MatchData

public class MatchData

存储正则表达式匹配结果，并提供对正则匹配结果进行查询的函数。

func matchStr

public func matchStr(): String

功能：返回上一次匹配到的子字符串，结果与调用 matchStr(0) 相同。

返回值：返回子字符串

异常：

  • IndexOutOfBoundsException：如果匹配字符串数组长度小于1，抛出异常

func matchStr

public func matchStr(group: Int64): String

功能：根据给定的索引获取上一次匹配中该捕获组匹配到的子字符串捕获组的索引从 1 开始，索引为 0 表示整个正则表达式的匹配结果。

参数：

  • group：指定组

返回值：返回子字符串

异常：

  • IndexOutOfBoundsException：如果输入值不符合规定，则抛异常

func matchPosition

public func matchPosition(): Position

功能：返回上一次匹配到的子字符串在输入字符串中起始位置的索引和最后一个字符匹配后的偏移索引。

返回值：Position – 返回匹配结果位置信息

异常：

  • IndexOutOfBoundsException：如果捕获数组长度小于1，抛出异常

func matchPosition

public func matchPosition(group: Int64): Position

功能：根据给定的索引获取上一次匹配中该捕获组匹配到的子字符串在输入字符串中的位置信息。

参数：

  • group：指定组

返回值：返回对应捕获组的位置信息

异常：

  • IndexOutOfBoundsException：如果输入值不符合规定，则抛异常

func groupNumber

public func groupNumber(): Int64

功能：返回捕获组的个数。

返回值：返回捕获组的个数

struct Position

public struct Position

Position 用来存储位置信息，表示的是一个前闭后开区间。

prop start

public prop start: Int64

功能：区间开始位置

prop end

public prop end: Int64

功能：区间结束位置

class RegexException

public class RegexException <: Exception {
    public init()
    public init(message: String)
}

RegexException 类提供的 API 如下所示：

init

public init()

功能：创建 RegexException。

init

public init(message: String)

功能：创建 RegexException。

参数：

  • message：异常提示字符串

regex 规则集

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

字符描述
\将下一个字符标记为一个特殊字符（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。(?:z|f)ood 则匹配zood或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}，即： a：组定义 1 被{m1,n1}修饰； b：组定义 1 被组定义 2 包裹； c：组定义 2 被{m2,n2}修饰。

示例

Regex 匹配大小写

创建 Regex 正则类，并简单匹配大小写, 使用 matches() 进行匹配。

代码如下：

from std import regex.*
main() {
  let r1 = Regex("ab")
  let r2 = Regex("ab", RegexOption().ignoreCase())
  match (r1.matches("aB")) {
      case Some(r) => println(r.matchStr())
      case None => println("None")
  }
  match (r2.matches("aB")) {
      case Some(r) => println(r.matchStr())
      case None => println("None")
  }
  return 0
}

运行结果如下：

None
aB

Matcher 中 resetString/fullMatch/matchStart 函数

使用 Regex 的 matcher 创建匹配器 Matcher 实例，使用 resetString 重新设值匹配序列，使用 fullMatch 和 matchStart 进行匹配。

代码如下：

from std import regex.*

main() {
    let r = Regex("\\d+")
    let m = r.matcher("13588123456")
    let matchData1 = m.fullMatch()
    m.resetString("13588abc")
    let matchData2 = m.matchStart()
    m.resetString("abc13588123abc")
    let matchData3 = m.matchStart()
    match (matchData1) {
        case Some(md) => println(md.matchStr())
        case None => println("None")
    }
    match (matchData2) {
        case Some(md) => println(md.matchStr())
        case None => println("None")
    }
    match (matchData3) {
        case Some(md) => println(md.matchStr())
        case None => println("None")
    }
    return 0
}

运行结果如下：

13588123456
13588
None

Matcher 和 MatchData 的使用

正则匹配贪婪量词，使用 find() 查看多次的匹配结果，使用 MatchData 的 matchPosition() 查看匹配的偏移值。

代码如下：

from std import regex.*

main() {
    let r = Regex(#"a\wa"#).matcher("1aba12ada555")
    for (i in 0..2) {
        let matchData = r.find()
        match (matchData) {
            case Some(md) =>
                println(md.matchStr())
                let pos = md.matchPosition()
                println("[${pos.start}, ${pos.end})")
            case None => println("None")
        }
    }
    return 0
}

运行结果如下：

aba
[1, 4)
ada
[6, 9)

Matcher 中 replace/replaceAll 函数

下面是使用 replace 和 replaceAll 示例。

代码如下：

from std import regex.*
main() {
  let r = Regex("\\d").matcher("a1b1c2d3f4")
  println(r.replace("X")) //replace a digit once with X
  println(r.replace("X", 2)) //replace once from index 4
  println(r.replaceAll("X")) //replace all digit with X
  println(r.replaceAll("X", 2)) //replace all at most 2 times
  println(r.replaceAll("X", -1)) //replace all digit with X
  return 0
}

运行结果如下：

aXb1c2d3f4
a1bXc2d3f4
aXbXcXdXfX
aXbXc2d3f4
aXbXcXdXfX

MatchOption 指定多行模式匹配

MatchOption 指定多行模式匹配。

代码如下：

from std import regex.*

main(): Int64 {
    let rule = ##"^(\w+)\s(\d+)*$"##
    let pattern: String = """
Joe 164
Sam 208
Allison 211
Gwen 171
"""

    let r1 = Regex(rule, RegexOption().multiLine())
    var arr = r1.matcher(pattern).findAll() ?? Array<MatchData>()
    for (md in arr) {
        println(md.matchStr())
    }
    return 0
}

运行结果如下：

Joe 164
Sam 208
Allison 211
Gwen 171

RegexOption 获取当前正则匹配模式

RegexOption 类可以获取当前正则匹配模式。

代码如下：

from std import regex.*
main()
{
    var a = RegexOption()
    println(a.toString())
    a = RegexOption().ignoreCase()
    println(a.toString())
    a = RegexOption().multiLine()
    println(a.toString())
    a = RegexOption().multiLine().ignoreCase()
    println(a.toString())
    return 0
}

运行结果如下：

NORMAL,NFA
IGNORECASE,NFA
MULTILINE,NFA
MULTILINE,IGNORECASE,NFA

MatchData 中 groupNumber 函数

调用 groupNumber() 查询 group 数，获取每个 group 的 MatchData 信息。

代码如下：

from std import regex.*

main() {
    var r = Regex("(a+c)(a?b)()(()?c+((e|s([a-h]*))))")
    var m = r.matcher("aacbcsdedd")
    var matchData = m.find()
    match (matchData) {
        case Some(s) =>
            println("groupNum : ${s.groupNumber()}")
            if (s.groupNumber() > 0) {
                for (i in 1..=s.groupNumber() ) {
                    println("group[${i}] : ${s.matchStr(i)}")
                    var pos = s.matchPosition(i)
                    println("position : [${pos.start}, ${pos.end})")
                }
            }
        case None => ()
    }

    return 0
}

运行结果如下：

groupNum : 8
group[1] : aac
position : [0, 3)
group[2] : b
position : [3, 4)
group[3] :
position : [4, 4)
group[4] : csdedd
position : [4, 10)
group[5] :
position : [10, 10)
group[6] : sdedd
position : [5, 10)
group[7] : sdedd
position : [5, 10)
group[8] : dedd
position : [6, 10)

Matcher 获取匹配总数

Matcher 类可以获取正则表达式匹配总数。

代码如下：

from std import regex.*

main() {
    var matcher = Regex("a+b").matcher("1ab2aab3aaab4aaaab")
    println(matcher.allCount())
    return 0
}

运行结果如下：

4