## [1] │ New <the>me
## [3] │ In <the> present <the>me

因为某些希望原样匹配的字符串中可能有元字符（对正则表达式需要特殊解释的字符）， 所以字面匹配的模式应该用 fixed() 函数保护。 在文件名中找到以 .txt 结尾的：

## [2] │ data<.txt>

## [1] │ <Dr>. Wang

通过在 regex() 函数中加选项 ignore_case=TRUE 可以进行不区分大小写的匹配：

## [1] │ <Dr>. Wang
## [2] │ <DR>. WANG
## [3] │ <dR>. W.R.

fixed() 函数也允许使用 ignore_case=TRUE ，如：

## [1] │ <Dr>. Wang
## [2] │ <DR>. WANG
## [3] │ <dR>. W.R.

在模式前面附加 (?i) 前缀式选项也可以实现不区分大小写匹配：

## [1] │ <Dr>. Wang
## [2] │ <DR>. WANG
## [3] │ <dR>. W.R.

## [1] │ <abc>
## [2] │ c<abs>

像句点这样的字符称为 元字符 （meta characters）， 在正则表达式中有特殊作用。 如果需要匹配句点本身，用“ [.] ”或者“ \. ”表示。 比如，要匹配 a.txt 这个文件名，如下做法有错误：

## [1] │ <a.txt>
## [2] │ <a0txt>

结果连 a0txt 也匹配了。用“[.]”表示句点则将句点不做特殊解释：

## [1] │ <a.txt>

## [1] │ <a.txt>

注意在R语言字符型常量中一个 \ 需要写成两个。

如果仅需按照原样进行查找， 也可以将 pattern 的字符串用 fixed() 函数保护，如：

## [1] │ <a.txt>

## [1] │ <sa1.xls>
## [2] │ d<na2.xls>s
## [3] │ <nat.xls>

注意匹配并不需要从开头匹配到结尾， 中间匹配是允许的，类似于搜索符合某种规律的子串。 在上例中第二个元素是从第二个字符开始匹配的，也没有匹配到末尾。

例：模式 [Rr]eg[Ee]x 可以匹配 RegEx 或 Regex 或 regex 或 regEx 。

在“ [] ”中有一些特殊字符：

例：下面的模式“ [ns]a[0-9][.]xls ”要求匹配的第三个字符为数字。

## [1] │ <sa1.xls>
## [2] │ d<na2.xls>s

例：模式 [ns]a[^0-9][.]xls 要求匹配的第三个字符不能为数字:

## [3] │ <nat.xls>

要求第三个字符为 ^ 或 - 的例子：

## [2] │ <5 - 3>
## [3] │ <5 ^ 3>

## [2] │ <int x[5]>

可以用原始字符串格式写成：

## [2] │ <int x[5]>

当然，因为模式中所有字符都不想作为特殊字符， 也可以用 fixed() 说明：

## [2] │ <int x[5]>

注意其中的方括号不需要用反斜杠保护。

## [1] │ <n1.xls>

## [1] │ file-<s1.>xls

可以看出，模式匹配了 s1. 而没有匹配 s#. 。

## [1] │ <x1>
## [2] │ <_x>
## [3] │ <.x>
## [4] │ <.1>

模式匹配长度为2的字符串， 第一个字符是字母、下划线或者小数点， 第二个字符是字母、数字、下划线或者小数点。 这个模式试图匹配由两个字符组成的合法R变量名， 但是最后一个非变量名 .1 也被匹配了。 解决这样的问题可以采用后面讲到的 | 备择模式。

## [1] │ <James>, Bond
## [2] │ <Jim> boy

两个字符的合法R变量名的匹配：

## [1] │ <x1>
## [2] │ <_x>
## [3] │ <.x>

## [1] │ <n1.xls>

只匹配了第一个输入字符串。

用“ \A ”和“ \Z ”的写法：

有时候源文本的每个字符串保存了一个文本文件内容， 各行用 \n 分隔， 后面将给出匹配每行的行首与行尾的方法。

## [1] │ a <cat> meaos

## [4] │ <sum>(x)

## [1] │ <sa1>
## [2] │ d<sa123>

例如，匹配电子邮件地址：

## [1] │ <abc123@efg.com>

匹配的电子邮件地址在 @ 前面可以使用任意多个字母、数字、下划线， 在 @ 后面由小数点分成两段， 每段可以使用任意多个字母、数字、下划线。 这里用了 ^ 和 $ 表示全字符串匹配。

## [1] │ <http://www.163.net>
## [2] │ <https://123.456.>

(注意第二个字符串不是合法网址但是按这个正则表达式也能匹配)

x[[:digit:]]* 能匹配“x”, “x1”, “x123”这样的变量名，如：

## [1] │ <x>
## [2] │ <x1>
## [3] │ <x123>

## [1] │ <x>
## [2] │ <x1>
## [3] │ <x123>

从上面的例子可以看出， 在指定某一字符类（或集合）重复时， 不需要严格重复前一字符， 而是只要保持同一类即可。

## [3] │ <123>
## [4] │ <123>4

模式匹配的是三位的数字。 因为没有要求从开头一直匹配到末尾， 所以三位以上数字也能匹配其中开始的三位。

可以在后缀大括号中指定重复的最小和最大次数， 中间用逗号分隔。 最小重复数允许指定为0。 重复数的逗号后面空置表示重复数没有上限。 例如，后缀 {3,} 表示前一模式必须至少重复3次。

例：月日年的日期格式可以用

[[:digit:]]{1,2}[-/][[:digit:]]{1,2}[-/][[:digit:]]{2,4}

比较长的正则表达式会很难认读， 我们可以用 paste0() 函数将其拆分为几个部分， 并对每一部分添加适当的注释。 如 (注意这个模式还会匹配非日期)

## [1] │ <2/4/1998>
## [2] │ <13/15/198>

也可以用 regex() 函数中加选项 comment=TRUE 加注释， 这时一个正则表达式可以写成多行， 在行尾添加注释， 所有原样空格必须转义或写在字符集中，如：

## [1] │ <2/4/1998>
## [2] │ <13/15/198>

## [1] │ <(1st) other (2nd)>

我们本来期望的是提取两个“(1st)”和“(2nd)”组合， 不料整个地提取了“ (1st) other (2nd) ”。 这就是因为 .+ 的贪婪匹配。

如果要求尽可能短的匹配， 使用 *? , +? , {3,}? 等“懒惰型”重复模式。 在无上限重复标志后面加问号表示懒惰性重复。

比如，上例中模式修改后得到了期望的结果：

## [1] │ <(1st)> other <(2nd)>

懒惰匹配会造成搜索效率降低， 应仅在需要的时候使用。

跨行匹配失败。

一种办法是预先用 str_replace_all() 或 gsub() 把所有换行符替换为空格。 但是这只能解决部分问题。

解决方法是在将模式用 regex() 保护并加选项 dotall=TRUE ， 使得句点通配符可以匹配换行符， 称为句点全匹配模式。

## [1] │ <(1,
##     │ 2)>

也可以在在Perl格式的正则表达式开头添加 (?s) 选项，

## [1] │ <(1,
##     │ 2)>

元数据中包含两行内容， 结果没有能够匹配， 这是因为模式要求从整个字符串开头一直匹配到末尾。

增加 multiline=TRUE 则可以对每行分别匹配， 结果找到两处匹配：

## [1] │ <(1,2)>
##     │ <(3,4)>
##     │

使用 (?m) 选项：

## [1] │ <(1,2)>
##     │ <(3,4)>
##     │

结果将是一个字符型向量， 每个元素是原来的一行，最后一个元素是空字符串。

## [1] "78"   "17"   "2035"

## [1] │ <http:>//baidu.com
## [2] │ <https:>//baidu.com
## [3] │ <ftp:>//baidu.com

这样的模式多匹配了一个“ : ”号。 可以用 str_match() 函数提取其中的捕获：

##      [,1]     [,2]   
## [1,] "http:"  "http" 
## [2,] "https:" "https"
## [3,] "ftp:"   "ftp"

结果是字符型矩阵，第二列是所需的内容。 但这样还是在整个匹配中包含了不需要的内容。

可以用 (?=) 包含要提取的模式的标志性后缀， 但匹配结果不包含这个后缀，如：

## [1] │ <http>://baidu.com
## [2] │ <https>://baidu.com
## [3] │ <ftp>://baidu.com

可见这次没有匹配“ : ”部分。 提取只要用 str_extract() ：

## [1] "http"  "https" "ftp"

## [1] │ http://<baidu.com>
## [2] │ https://<baidu.com>
## [3] │ ftp://<baidu.com>

可见仅匹配了 // 后面的内容。

## [1] "baidu.com" "baidu.com" "baidu.com"

还可以用 (?!) 包含不允许的后缀， 用 (?<!) 包含不允许的前缀。

## [1] │ <1978-1-03>
## [2] │ <1911-07-31>
## [3] │ <2023-10-18>

可以用 str_flatten(subpats, sep) 将保存在向量 subpats 中的元素用 sep 分隔符连接起来， 组成一个长模式。 为防止输入的内容有元字符， 可以用 str_escape() 进行转义。 str_escape() 将输入内容中的正则表达式元字符转义为原样匹配，

## [1] "x\\[1\\] = myfile\\.txt"

例：要匹配保存在字符型向量中的任何一个颜色名， 将这些颜色名用 | 连接成一个长的正则表达式后匹配。

## [1] │ A <red> fox
## [3] │ <Green> sleeves

## [1] │ New <the>me
## [3] │ In <the> present <the>me

## [1]  TRUE FALSE  TRUE

上例中的 str_view() 仅用作调试目的。

当要查找的内容是tibble的一列时， 用 filter() 与 str_detct() 配合， 可以进行行子集选择。 比如，在数据框的人名中查找中间有空格的名字：

## # A tibble: 1 × 1
##   name  
##   <chr> 
## 1 李  明

可以在 dplyr::summarize() 中用 sum(str_detect(x, pat)) 计算符合模式的观测个数， 用 mean 计算比例。

因为 str_detect() 返回与输入源字符串向量等长的逻辑型向量， 所以特别适用于用逻辑运算来满足复杂的条件。 在姓名中找到同时有 a 和 y 的：

## [1] "Kathy" "Mary"  "Sandy"

有 a 或有 y 的：

## [1] "Becka" "Gail"  "Karen" "Kathy" "Mary"  "Sandy"

用这种方法可以将复杂的匹配条件拆分为多个条件， 并用与、或、非组合起来。

## [1] 6 3 0

正则表达式在匹配时， 是否允许同一源字符串中的两次匹配有重叠部分？ 这是不允许的。

## [1] │ <121>2<121>

## [1] 2

如果允许重叠， 就可以有3次 121 模式。

## [2] │ [<李  明>]

## [1] "[李  明]"

注意上例中仅返回了有匹配的元素， 而且是匹配元素的整个字符串而不是匹配的部分。

str_which(string, pattern) 返回字符型向量 string 的元素当中能匹配 pattern 中的模式的元素序号。 与基本R的 grep() 作用类似。

## [1] 1 3

## [1] │ A f<all>ing b<all>

## [1] "all"

注意第二个输入字符串不匹配所有返回结果中不包含该元素的对应输出。 这会造成结果的对应困难， 所以应仅在确保所有输入都能匹配时才使用 str_extract() 这个函数， 一般应使用 str_extract_all() 。

str_extract_all(string, pattern) 取出所有匹配子串， 结果是一个列表， 长度与输入的字符型向量 string 的元素个数相等， 列表的每个元素对应于 string 的每个元素。 结果列表的每个元素是一个字符型数组， 存放所有匹配的子字符串， 没有匹配的输入字符串对应的输出元素是空向量（长度为0的向量）。

## [1] │ A f<all>ing b<all>
## [2] │ Phone c<all>.

## [[1]]
## [1] "all" "all"
## [[2]]
## [1] "all"
## [[3]]
## character(0)

str_extract_all() 可以加选项 simplyfy=TRUE ， 使得返回结果变成一个字符型矩阵， 每行是原来一个元素中取出的各个子串， 列数等于最大匹配次数， 没有那么多匹配次数的填以空字符串。 如果正常匹配结果不会出现空字符就可以用这种方法简化结果的保存和访问。

##      [,1]  [,2] 
## [1,] "all" "all"
## [2,] "all" ""   
## [3,] ""    ""

##      [,1]     [,2] [,3]
## [1,] NA       NA   NA  
## [2,] "李  明" "李" "明"

上例中源数据第一个元素没有匹配， 所以结果都是缺失值 NA ， 第二个元素的结果在第二行， 首先是整个匹配的子字符串， 然后是捕获的两个部分。

stringr::str_match_all(string, pattern) 匹配每个字符串中所有出现位置， 结果是一个列表， 每个列表元素对应于输入的字符型向量 string 的每个元素， 结果中每个列表元素是一个字符型矩阵， 用来保存所有各个匹配以及匹配中的捕获， 每行是一个匹配的结果，首先是匹配结果，其次是各个捕获。 结果列表中每个作为列表元素的矩阵大小不一定相同。 当某个元素完全没有匹配时， 结果列表中对应元素是行数为0的矩阵。

比如，模式为19xx或者20xx的年份， 并将其分为前两位和后两位：

## [1] │ <1978>-<2000>
## [2] │ <2011>-<2020>-<2099>

## [[1]]
##      [,1]   [,2] [,3]
## [1,] "1978" "19" "78"
## [2,] "2000" "20" "00"
## [[2]]
##      [,1]   [,2] [,3]
## [1,] "2011" "20" "11"
## [2,] "2020" "20" "20"
## [3,] "2099" "20" "99"
## [[3]]
##      [,1] [,2] [,3]

下面的程序合并上面提取的年份后两位为一个字符型向量：

## [1] "78" "00" "11" "20" "99"

用基本R功能：

## [1] "78" "00" "11" "20" "99"

## [1] │ A f<all>ing b<all>
## [2] │ Phone c<all>.

##      start end
## [1,]     4   6
## [2,]     8  10

str_locate_all(string, pattern) 则可以返回每个元素中所有匹配的开始和结束位置， 结果是一个列表， 每个列表元素对应于输入字符型向量的每个元素， 结果中每个列表元素是一个两列的数值型矩阵， 每行为一个匹配的开始和结束字符序号。如

## [1] │ A f<all>ing b<all>
## [2] │ Phone c<all>.

## [[1]]
##      start end
## [1,]     4   6
## [2,]    12  14
## [[2]]
##      start end
## [1,]     8  10

注意如果需要取出匹配的元素可以用 str_subset() ， 要取出匹配的子串可以用 str_extract() 和 str_extract_all() ， 取出匹配的子串以及分组捕获可以用 str_match() 和 str_match_all() 。

## [1]  5 -1  4
## attr(,"match.length")
## [1]  3 -1  3
## attr(,"index.type")
## [1] "chars"
## attr(,"useBytes")
## [1] TRUE

这里使用了 regexpr 函数。 regexpr 函数的一般用法为：

自变量为：

regexpr() 函数返回一个整数值的向量， 长度与 text 向量长度相同， 结果的每个元素是在 text 的对应元素中 pattern 的首次匹配位置； 没有匹配时结果元素取-1。 结果会有一个 match.length 属性，表示每个匹配的长度， 无匹配时取-1。

如果仅关心源字符串向量 text 中哪些元素能匹配 pattern ， 可以用 grep 函数，如

## [1] 1 3

结果说明源字符串向量的三个元素中仅有第1、第3号元素能匹配。 如果都不匹配，返回 integer(0) 。

grep 可以使用与 regexpr 相同的自变量， 另外还可以加选项 invert=TRUE ，这时返回的是不匹配的元素的下标。

grep() 如果添加选项 value=TRUE ， 则结果不是返回有匹配的元素的下标而是返回有匹配的元素本身（不是匹配的子串），

## [1] "New theme"            "In the present theme"

grepl 的作用与 grep 类似， 但是其返回值是一个长度与源字符串向量 text 等长的逻辑型向量， 每个元素的真假对应于源字符串向量中对应元素的匹配与否。如

## [1]  TRUE FALSE  TRUE

就像 grep() 与 grepl() 本质上给出相同的结果，只是结果的表示方式不同， regexec() 与 regexpr() 也给出仅在表示方式上有区别的结果。 regexpr() 主要的结果是每个元素的匹配位置， 用一个统一的属性返回各个匹配长度； regexec() 则返回一个与源字符串向量等长的列表， 列表的每个元素为匹配的位置，并且列表的每个元素有匹配长度作为属性。 所以，这两个函数只需要用其中一个就可以，下面仅使用 regexpr() 。 regexec() 的使用效果如

## [[1]]
## [1] 5
## attr(,"match.length")
## [1] 3
## attr(,"useBytes")
## [1] TRUE
## attr(,"index.type")
## [1] "chars"
## [[2]]
## [1] -1
## attr(,"match.length")
## [1] -1
## attr(,"useBytes")
## [1] TRUE
## attr(,"index.type")
## [1] "chars"
## [[3]]
## [1] 4
## attr(,"match.length")
## [1] 3
## attr(,"useBytes")
## [1] TRUE
## attr(,"index.type")
## [1] "chars"

grep() , grepl() , regexpr() , regexec() 都只能找到源字符串向量的每个元素中模式的首次匹配， 不能找到所有匹配。 gregexpr() 函数可以找到所有匹配。

## [[1]]
## [1] 5
## attr(,"match.length")
## [1] 3
## attr(,"index.type")
## [1] "chars"
## attr(,"useBytes")
## [1] TRUE
## [[2]]
## [1] -1
## attr(,"match.length")
## [1] -1
## attr(,"index.type")
## [1] "chars"
## attr(,"useBytes")
## [1] TRUE
## [[3]]
## [1]  4 16
## attr(,"match.length")
## [1] 3 3
## attr(,"index.type")
## [1] "chars"
## attr(,"useBytes")
## [1] TRUE

其结果是一个与源字符串向量等长的列表， 格式与 regexec() 的结果格式类似， 列表的每个元素对应于源字符串向量的相应元素， 列表元素值为匹配的位置， 并有属性 match.length 保存了匹配长度。 匹配位置和匹配长度包含了所有的匹配， 见上面例子中第三个元素的匹配结果。

函数 grep , grepl 结果仅给出每个元素能否匹配。 regexpr() , regexec() , gregexpr() 则包含了匹配位置与匹配长度， 这时，可以用 regmatches() 函数取出具体的匹配字符串。 regmatches() 一般格式为

其中 x 是源字符串向量， m 是 regexpr() 、 regexec() 或 gregexpr() 的匹配结果。

## [1] "the" "the"

可以看出， regmatches() 仅取出有匹配时的匹配内容， 无匹配的内容被忽略。

取出多处匹配的例子如：

## [[1]]
## [1] "the"
## [[2]]
## character(0)
## [[3]]
## [1] "the" "the"

当 regmatches() 第二个自变量是 gregexpr() 的结果时， 其输出结果变成一个列表， 并且不再忽略无匹配的元素， 无匹配元素对应的列表元素为 character(0) ， 即长度为零的字符型向量。 对有匹配的元素， 对应的列表元素为所有的匹配字符串组成的字符型向量。

## [1] 1

## [1] 1 2 3

## [1] 1 2 3

## [1]  1  2 -1
## attr(,"match.length")
## [1]  3  3 -1
## attr(,"index.type")
## [1] "chars"
## attr(,"useBytes")
## [1] TRUE

regexpr 仅给出每个元素中模式的首次匹配位置而不是给出匹配的内容。 regmatches 函数以原始字符型向量和匹配结果为输入， 结果返回每个元素中匹配的各个子字符串(不是整个元素)，如:

## [1] "abc" "abs"

注意返回结果和输入字符型向量元素不是一一对应的，仅返回有匹配的结果。

像句点这样的字符称为元字符（meta characters）， 在正则表达式中有特殊函数。 如果需要匹配句点本身，用“ [.] ”或者“ \. ”表示。 比如，要匹配 a.txt 这个文件名，如下做法有错误：

## [1] 1 2

结果连 a0txt 也匹配了。用“[.]”表示句点则将句点不做特殊解释：

## [1] 1

## [1] 1

注意在R语言字符型常量中一个 \ 需要写成两个。

如果仅需按照原样进行查找， 也可以在 grep() , grepl() ， regexpr() ， gregexpr() 等函数中加选项 fixed=TRUE ， 这时不要再用 perl=TRUE 选项。

## [1] 1

## [1] 1 2 1
## attr(,"match.length")
## [1] 7 7 7
## attr(,"index.type")
## [1] "chars"
## attr(,"useBytes")
## [1] TRUE

## [1] 2

也可以用“ [[] ”表示“ [ ”， 用“ []] ”表示“ ] ”，如

## [1] 2

## [1] 1

## [1] 1

## [1] 1

只匹配了第一个输入字符串。

## [1] "s1."

可以看出，模式匹配了 s1. 而没有匹配 s#. 。

## [1] 4 8
## attr(,"match.length")
## [1] 1 1
## attr(,"index.type")
## [1] "chars"
## attr(,"useBytes")
## [1] TRUE

匹配了两个换行符。

## [1] 1 2 3 4

## [1] "sa1"   "sa123"

## [1] "abc123@efg.com"

匹配的电子邮件地址在 @ 前面可以使用任意多个字母、数字、下划线， 在 @ 后面由小数点分成两段， 每段可以使用任意多个字母、数字、下划线。 这里用了 ^ 和 $ 表示全字符串匹配。

## [1] 1 2

(注意第二个字符串不是合法网址但是按这个正则表达式也能匹配)

## [1] 3 4

模式匹配的是三位的数字。

日期匹配例：

## [1] 1 2

## [1] "<B>1st</B> other <B>2nd</B>"

我们本来期望的是提取第一个“ <B> …… </B> ”组合， 不料提取了两个“ <B> …… </B> ”组合以及中间的部分。

比如，上例中模式修改后得到了期望的结果：

## [1] "<B>1st</B>"

## [1] 1

## integer(0)

跨行匹配失败。而在HTML的规范中换行是正常的。 一种办法是预先用 gsub 把所有换行符替换为空格。 但是这只能解决部分问题。

另一方法是在Perl正则表达式开头添加 (?s) 选项， 这个选项使得句点通配符可以匹配换行符。

## [1] "<B>1st\n</B>"

多行模式例：

## [1] "<B>"

## [1] "<B>"  "</B>"

字符串 s 包含两行内容，中间用 \n 分隔。 mres1 的匹配模式没有打开多行选项， 所以模式中的 ^ 只能匹配 s 中整个字符串开头。 mres2 的匹配模式打开了多行选项， 所以模式中的 ^ 可以匹配 s 中每行的开头。

## [[1]]
## [1] "James"
## [[2]]
## [1] "Jim"

## [1] "1st other 2nd"

替换模式中的 \1 (写成R字符型常量时 \ 要写成 \\ )表示第一个圆括号匹配的内容， 但是表示选项的圆括号（ (?s) ）不算在内。

例：希望把带有前导零的数字的前导零删除，可以用如

## [1] "123" "123" "123"

其中的 \b 模式表示单词边界， 这可以排除在一个没有用空格或标点分隔的字符串内部拆分出数字的情况。

例：为了交换横纵坐标，可以用如下替换

## [1] "1st: (3.6, 5), 2nd: (1.1, 2.5)"

例如，要匹配yyyy-mm-dd这样的日期， 并将其改写为mm/dd/yyyy， 就可以用这样的替换模式：

## [1] "05/31/1998" "01/14/2017"

分组除了可以做替换外， 还可以用来表示模式中的重复出现内容。 例如， ([a-z]{3})\1 这样的模式可以匹配如 abcabc , uxzuxz 这样的三字母重复。如

## [1] 1

又例如，下面的程序找出了年（后两位）、月、日数字相同的日期：

## [1] "2008-08-08"

下面是一个非捕获分组示例。 设需要把1921-2020之间的世纪号删去，可以用

## [1] "78" "17" "35"

其中用了非捕获分组使得备择模式 19|20 优先匹配。 注意模式并没有能保证日期在1921-2020之间。更周密的程序可以写成：