正则表达式及程序应用

正则表达式

正则表达式基础

1.元字符

有特定含义的字符，常见的元字符如下

代码	说明
.	匹配任意字符。（但是Python和Hive中**.**无法匹配换行符。MySQL8.0中使用regexp_like()函数时可以在match_type中设定是否要匹配换行符。）
\w	匹配字母或数字或下划线或汉字(等价于’[A-Za-z0-9_]')
\s	匹配任意的空白符(等价于[ \f\n\r\t\v])
\d	匹配数字(等价于[0-9])
\b	匹配单词的开始或结束即单词的边界 —位置匹配的锚点
^	匹配字符串的开始（在集合字符里表示非（不匹配）的意思 --位置匹配的锚点
$	匹配字符串的结束 --位置匹配的锚点

2.反义字符

与元字符相反，不满足某些特定含义的字符

代码/语法	说明
\W	匹配任意不是字母，数字，下划线，汉字的字符
\S	匹配任意不是空白符的字符
\D	匹配任意非数字的字符
\B	匹配不是单词开头或结束的位置
[^x]	匹配除了x以外的任意字符
[^aeiou]	匹配除了aeiou这几个字母以外的任意字符

位置匹配

3.限定字符

限定字符多用于重复匹配次数

代码/语法	说明
*	重复零次或更多次
+	重复一次或更多次
?	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多次
{n,m}	重复n到m次

4.转义字符

正则表达式中有转义字符，其作用主要是对正则表达式中的元字符进行转义，使其可以匹配元字符本身而不是其特殊的元字符含义。一般的编程语言(包含SQL)中也都有转义字符的概念，这些转义字符通常都有特殊的含义，比如在windows系统中，‘\n’指示换行。两类转义字符都以’'开始。这里具体对两类转义字符进行说明。

1.常见编程语言中的转义字符

转义字符	描述
\	在行尾时为续行符
\\	反斜杠符号
\’	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)
\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数，yy代表的字符，例如：\o12代表换行 十六进制为\xyy

在Python和MySQL中，这些转义字符作为一个整体执行特殊的作用，以’\n’为例：

 print('hello\nword')
 print('\n')   

在Python中，‘\'和其后的字符如果不能组成转义字符，Python会把他们当成两个字符处理。而MySQL中，则是直接将‘\’忽略了，只保留了其后的字符串。

select '\t' as result;
select '\n' as result;  --(直接查询结果为1)

在正则表达式中，.，^，$，[，]，**等都有特定的含义。如果在正则表达式中想与这些字符本身进行匹配的的，需要在这些元字符前加上**对其进行转义。

正则表达式其实也是一种字符串，无论是Python还是MySQL，处理正则表达式的时候，编程语言自身要现行处理字符串，之后正则表达式才会处理。

比如在MySQL和HIVE中， MySQL和HIVE会先将‘\\w’编译成‘\w’，然后将其交给正则表达式处理。

5.字符分支

字符分枝多用于满足不同情况的选择，用“|”将不同的条件分割开来，比如有些固定电话区号有三位，有些有四位，这个时候可以采用字符分枝

例如：\d{3}-\d{8}|\d{4}-\d{8} 可以匹配两种不同长度区号的固定电话

6.字符分组

字符分组多用于将多个字符重复，主要通过使用小括号()来进行分组

形如：（\d\w){3} 重复匹配3次（\d\w)

常用分组语法

分类	代码/语法	说明
捕获	(exp)	匹配exp,并捕获文本到自动命名的组里
捕获	(?exp)	匹配exp,并捕获文本到名称为name的组里，也可以写成(?'name’exp)
捕获	(?:exp)	匹配exp,不捕获匹配的文本，也不给此分组分配组号
零宽断言	(?=exp)	匹配exp前面的位置
零宽断言	(?<=exp)	匹配exp后面的位置
零宽断言	(?!exp)	匹配后面跟的不是exp的位置
零宽断言	(?<!exp)	匹配前面不是exp的位置
注释	(?#comment)	这种类型的分组不对正则表达式的处理产生任何影响，用于提供注释让人阅读

7.后向引用

后向引用用于重复搜索前面某个分组匹配的文本。

使用小括号指定一个子表达式后，匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下，每个分组会自动拥有一个组号，规则是：从左向右，以分组的左括号为标志，第一个出现的分组的组号为1，第二个为2，以此类推

示例：\b(\w+)\b\s+\1\b可以用来匹配重复的单词，像go go, 或者kitty kitty。

这个表达式首先是一个单词，也就是单词开始处和结束处之间的多于一个的字母或数字(\b(\w+)\b)，这个单词会被捕获到编号为1的分组中，然后是1个或几个空白符(\s+)，最后是分组1中捕获的内容（也就是前面匹配的那个单词）(\1)。

你也可以自己指定子表达式的组名。要指定一个子表达式的组名，请使用这样的语法：(?\w+)(或者把尖括号换成’也行：(?‘Word’\w+)),这样就把\w+的组名指定为Word了。要反向引用这个分组捕获的内容，你可以使用\k,所以上一个例子也可以写成这样：\b(?\w+)\b\s+\k\b

8.零宽断言

有时候需要查找某些匹配之前或之后的东西，这个时候就需要用到们像\b,^,$那样用于指定一个位置，这个位置应该满足一定的条件(即断言)，因此它们也被称为零宽断言

(?=exp)也叫零宽度正预测先行断言，它断言自身出现的位置的后面能匹配表达式exp。比如\b\w+(?=ing\b)，匹配以ing结尾的单词的前面部分(除了ing以外的部分)，如查找I’m singing while you’re dancing.时，它会匹配sing和danc。

(?<=exp)也叫零宽度正回顾后发断言，它断言自身出现的位置的前面能匹配表达式exp。比如(?<=\bre)\w+\b会匹配以re开头的单词的后半部分(除了re以外的部分)，例如在查找reading a book时，它匹配ading。

9.懒惰匹配和贪婪匹配

默认是贪婪模式；在量词后面直接加上一个问号？就是非贪婪模式。

贪婪匹配：正则表达式中包含重复的限定符时，通常的行为是匹配尽可能多的字符。

懒惰匹配，有时候需要匹配尽可能少的字符。

例如： a.*b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。但是我们此时可能需要匹配的是ab这样的话就需要用到懒惰匹配了。懒惰匹配会匹配尽可能少的字符

常用的懒惰匹配限定符如下

代码/语法	说明
*?	重复任意次，但尽可能少重复
+?	重复1次或更多次，但尽可能少重复
??	重复0次或1次，但尽可能少重复
{n,m}?	重复n到m次，但尽可能少重复
{n,}?	重复n次以上，但尽可能少重复

编程语言对于正则表达式的应用

1.python

正则表达式对象

re.RegexObject

re.compile() 返回 RegexObject 对象。

re.MatchObject

group() 返回被 RE 匹配的字符串。

• start() 返回匹配开始的位置
• end() 返回匹配结束的位置
• span() 返回一个元组包含匹配 (开始,结束) 的位置

常用案例

*‘(?P…)’* 分组匹配

import re
s = '1102231990xxxxxxxx'
res = re.search('(?P<province>\d{3})(?P<city>\d{3})(?P<born_year>\d{4})',s)
print(res.groupdict())

#将匹配结果直接转化为字典模式
#{'province': '110', 'city': '223', 'born_year': '1990'}

import re

#match和search是匹配一次


#re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 none
re.match(pattern, string, flags=0)


#实例   ()里面为分组
line = "with temp as (select 1 from 2) \nselect "
matchObj = re.match(r'with\s*.*?\s*as\s*\((.*)\) ', line, re.M | re.I)
if matchObj:
    print("matchObj.group() : ", matchObj.group())
    print("matchObj.group(1) : ", matchObj.group(1))
    
    
    
    
#re.search 扫描整个字符串并返回第一个成功的匹配,其他与match同理   
re.search(pattern, string, flags=0)

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

我们可以使用 group(num) 或 groups() 匹配对象函数来获取匹配表达式。

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VYKYOfCL-1655260894255)(F:\学习文件\正则匹配之group.png)]

检索和替换

re.sub 函数 —replace

re.sub(pattern, repl, string, count=0, flags=0)

phone = "2004-959-559 # 这是一个国外电话号码"
 
# 删除字符串中的 Python注释 
num = re.sub(r'#.*$', "", phone)
print "电话号码是: ", num
 
# 删除非数字(-)的字符串 
num = re.sub(r'\D', "", phone)
print "电话号码是 : ", num


def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))

参数	描述
pattern	匹配的正则表达式
repl	替换的字符串，也可为一个函数
string	要被查找替换的原始字符串
count	模式匹配后替换的最大次数，默认 0 表示替换所有的匹配

re.compile 函数 —编译正则表达式

#compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用
re.compile(pattern[, flags])

pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字
m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
m.group(0)   # 可省略 0
m.start(0)   # 可省略 0
m.end(0)     # 可省略 0
m.span(0)    # 可省略 0

• pattern : 一个字符串形式的正则表达式

• flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：

  1. re.I 忽略大小写
  2. re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
  3. re.M 多行模式
  4. re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
  5. re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
  6. re.X 为了增加可读性，忽略空格和 # 后面的注释

  返回对象：

  在上面，当匹配成功时返回一个 Match 对象，其中：

  • group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；

  • start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；

  • end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；

  • span([group]) 方法返回 (start(group), end(group))。

re.findall 函数 --匹配所有子串

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。

注意： match 和 search 是匹配一次 findall 匹配所有。

pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
 
print(result1)
#['123', '456']
print(result2)
#['88', '12']


result = re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
print(result)
#[('width', '20'), ('height', '10')]

re.finditer 函数 --匹配所有字段及作为迭代器返回

re.finditer(pattern, string, flags=0)

it = re.finditer(r"\d+","12a32bc43jf3") 
for match in it: 
    print (match.group() )

与findalll函数相比多了一个迭代器功能，将元组列表遍历出来，更适合查询字符串满足条件的子串

re.split函数 --按照匹配的子串将字符串分割后返回列表

re.split(pattern, string[, maxsplit=0, flags=0])


>>>import re
>>> re.split('\W+', 'runoob, runoob, runoob.')
['runoob', 'runoob', 'runoob', '']
#在末尾以非字母，数字，下划线，汉字的字符结尾时会再分割出一个空格

>>> re.split('(\W+)', ' runoob, runoob, runoob.') 
['', ' ', 'runoob', ', ', 'runoob', ', ', 'runoob', '.', '']
#分割时候会把满足正则表达式的子串表示出来


>>> re.split('\W+', ' runoob, runoob, runoob.', 1) 
['', 'runoob, runoob, runoob.']
#因为第一个就是空格，所以会按第一个满足正则表达式的位置做出切割
 
>>> re.split('a*', 'hello world')   # 对于一个找不到匹配的字符串而言，split 不会对其作出分割
['hello world']

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串
maxsplit	分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志

2.Java

java正则表达式通过java.util.regex包下的Pattern类与Matcher类实现(建议在阅读本文时,打开java API文档,当介绍到哪个方法时,查看java API中的方法说明,效果会更佳).

Pattern类用于创建一个正则表达式,也可以说创建一个匹配模式,它的构造方法是私有的,不可以直接创建,但可以通过Pattern.complie(String regex)简单工厂方法创建一个正则表达式

Pattern p=Pattern.compile("\\w+"); 
p.pattern();//返回 \w+ 

pattern() 返回正则表达式的字符串形式,其实就是返回Pattern.complile(String regex)的regex参数

1.Pattern.split(CharSequence input)

Pattern有一个split(CharSequence input)方法,用于分隔字符串,并返回一个String[],我猜String.split(String regex)就是通过Pattern.split(CharSequence input)来实现的

Pattern p=Pattern.compile("\\d+"); 
String[] str=p.split("我的QQ是:456456我的电话是:0532214我的邮箱是:aaa@aaa.com"); 
//str[0]="我的QQ是:" str[1]="我的电话是:" str[2]="我的邮箱是:aaa@aaa.com" 

2.Pattern.matches(String regex,CharSequence input)

Pattern.matches是一个静态方法，用于快速匹配字符串，该方法适合用于只匹配一次，且匹配全部字符串

Pattern.matches("\\d+","2223");//返回true 
Pattern.matches("\\d+","2223aa");//返回false,需要匹配到所有字符串才能返回true,这里aa不能匹配到 
Pattern.matches("\\d+","22bb23");//返回false,需要匹配到所有字符串才能返回true,这里bb不能匹配到 

3.Pattern.matcher(CharSequence input)

说了这么多,终于轮到Matcher类登场了，Pattern.matcher(CharSequence input)返回一个Matcher对象，Matcher类的构造方法也是私有的,不能随意创建,只能通过Pattern.matcher(CharSequence input)方法得到该类的实例
Pattern类只能做一些简单的匹配操作,要想得到更强更便捷的正则匹配操作,那就需要将Pattern与Matcher一起合作.Matcher类提供了对正则表达式的分组支持,以及对正则表达式的多次匹配支持

Pattern p=Pattern.compile("\\d+"); 
Matcher m=p.matcher("22bb23"); 
m.pattern();//返回p 也就是返回该Matcher对象是由哪个Pattern对象的创建的 

4.Matcher.matches()/ Matcher.lookingAt()/ Matcher.find()

Matcher类提供三个匹配操作方法，三个方法均返回boolean类型，当匹配到时返回true，没匹配到则返回false
matches()对整个字符串进行匹配，只有整个字符串都匹配了才返回true

Pattern p=Pattern.compile("\\d+"); 
Matcher m=p.matcher("22bb23"); 
m.matches();//返回false,因为bb不能被\d+匹配,导致整个字符串匹配未成功. 
Matcher m2=p.matcher("2223"); 
m2.matches();//返回true,因为\d+匹配到了整个字符串

我们现在回头看一下Pattern.matcher(String regex,CharSequence input)，它与下面这段代码等价，Pattern.compile(regex).matcher(input).matches() lookingAt()对前面的字符串进行匹配，只有匹配到的字符串在最前面才返回true

Pattern p=Pattern.compile("\\d+"); 
Matcher m=p.matcher("22bb23"); 
m.lookingAt();//返回true,因为\d+匹配到了前面的22 
Matcher m2=p.matcher("aa2223"); 
m2.lookingAt();//返回false,因为\d+不能匹配前面的aa 

find()对字符串进行匹配,匹配到的字符串可以在任何位置

Pattern p=Pattern.compile("\\d+"); 
Matcher m=p.matcher("22bb23"); 
m.find();//返回true 
Matcher m2=p.matcher("aa2223"); 
m2.find();//返回true 
Matcher m3=p.matcher("aa2223bb"); 
m3.find();//返回true 
Matcher m4=p.matcher("aabb"); 
m4.find();//返回false 

5.Mathcer.start()/ Matcher.end()/ Matcher.group()

当使用matches(),lookingAt(),find()执行匹配操作后,就可以利用以上三个方法得到更详细的信息

start()返回匹配到的子字符串在字符串中的索引位置.
end()返回匹配到的子字符串的最后一个字符在字符串中的索引位置
group()返回匹配到的子字符串

Pattern p=Pattern.compile("\\d+"); 
Matcher m=p.matcher("aaa2223bb"); 
m.find();//匹配2223 
m.start();//返回3 
m.end();//返回7,返回的是2223后的索引号 
m.group();//返回2223 
 
Mathcer m2=m.matcher("2223bb"); 
m.lookingAt();   //匹配2223 
m.start();   //返回0,由于lookingAt()只能匹配前面的字符串,所以当使用lookingAt()匹配时,start()方法总是返回0 
m.end();   //返回4 
m.group();   //返回2223 
 
Matcher m3=m.matcher("2223bb"); 
m.matches();   //匹配整个字符串 
m.start();   //返回0,原因相信大家也清楚了 
m.end();   //返回6,原因相信大家也清楚了,因为matches()需要匹配所有字符串 
m.group();   //返回2223bb 

说了这么多,相信大家都明白了以上几个方法的使用，该说说正则表达式的分组在java中是怎么使用的 start()，end()，group()均有一个重载方法它们是start(int i)，end(int i)，group(int i)专用于分组操作，Mathcer类还有一个groupCount()用于返回有多少组

Pattern p=Pattern.compile("([a-z]+)(\\d+)"); 
Matcher m=p.matcher("aaa2223bb"); 
m.find();   //匹配aaa2223 
m.groupCount();   //返回2,因为有2组 
m.start(1);   //返回0 返回第一组匹配到的子字符串在字符串中的索引号 
m.start(2);   //返回3 
m.end(1);   //返回3 返回第一组匹配到的子字符串的最后一个字符在字符串中的索引位置. 
m.end(2);   //返回7 
m.group(1);   //返回aaa,返回第一组匹配到的子字符串 
m.group(2);   //返回2223,返回第二组匹配到的子字符串 

现在我们使用一下稍微高级点的正则匹配操作,例如有一段文本,里面有很多数字,而且这些数字是分开的,我们现在要将文本中所有数字都取出来

Pattern p=Pattern.compile("\\d+"); 
Matcher m=p.matcher("我的QQ是:456456 我的电话是:0532214 我的邮箱是:aaa123@aaa.com"); 
while(m.find()) { 
     System.out.println(m.group()); 
} 
 
//输出: 
 
456456 
0532214 
123 
 
 
//如将以上while()循环替换成 
 
while(m.find()) { 
     System.out.println(m.group()); 
     System.out.print("start:"+m.start()); 
     System.out.println(" end:"+m.end()); 
} 
 
//则输出: 
 
456456 
start:6 end:12 
0532214 
start:19 end:26 
123 
start:36 end:39 

现在大家应该知道,每次执行匹配操作后start(),end(),group()三个方法的值都会改变,改变成匹配到的子字符串的信息,以及它们的重载方法,也会改变成相应的信息
注意:只有当匹配操作成功,才可以使用start(),end(),group()三个方法,否则会抛出java.lang.IllegalStateException,也就是当matches(),lookingAt(),find()其中任意一个方法返回true时,才可以使用

6.常用的正则表达式

（1） “^\d+$”　　//非负整数（正整数 + 0）

（2） “¹[1-9][0-9]$”　　//正整数

（3） “^((-\d+)|(0+))$”　　//非正整数（负整数 + 0）

（4） “^-[0-9][1-9][0-9]$”　　//负整数

（5） “^-?\d+$”　　　　//整数

（6） “^\d+(.\d+)?$”　　//非负浮点数（正浮点数 + 0）

（7） “^(([0-9]+.[0-9][1-9][0-9])|([0-9][1-9][0-9].[0-9]+)|([0-9][1-9][0-9]))$”　　//正浮点数

（8） “^((-\d+(.\d+)?)|(0+(.0+)?))$”　　//非正浮点数（负浮点数 + 0）

（9） “^(-(([0-9]+.[0-9][1-9][0-9])|([0-9][1-9][0-9].[0-9]+)|([0-9][1-9][0-9])))$”　　//负浮点数

（10） “^(-?\d+)(.\d+)?$”　　//浮点数

（11） “²+$”　　//由26个英文字母组成的字符串

（12） “³+$”　　//由26个英文字母的大写组成的字符串

（13） “⁴+$”　　//由26个英文字母的小写组成的字符串

（14） “⁵+$”　　//由数字和26个英文字母组成的字符串

（15） “^\w+$”　　//由数字、26个英文字母或者下划线组成的字符串

（16） “⁶+(.[\w-]+)*@[\w-]+(.[\w-]+)+$”　　　　//email地址

（17） “⁷+://(\w+(-\w+))(.(\w+(-\w+)))(?\S)?$”　　//url

（18） /^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-((0-2)|(3[0|1]))$/ // 年-月-日

（19） /^((0([1-9]{1}))|(1[1|2]))/((0-2)|(3[0|1]))/(d{2}|d{4})$/ // 月/日/年

（20） “^([w-.]+)@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-]+.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$” //Emil

（21） /^((+?[0-9]{2,4}-[0-9]{3,4}-)|([0-9]{3,4}-))?([0-9]{7,8})(-[0-9]+)?$/ //电话号码

（22） “^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$” //IP地址

（23）

（24） 匹配中文字符的正则表达式： [\u4e00-\u9fa5]

（25） 匹配双字节字符(包括汉字在内)：[^\x00-\xff]

（26） 匹配空行的正则表达式：\n[\s| ]*\r

（27） 匹配HTML标记的正则表达式：/<(.)>.</\1>|<(.*) />/

（28） 匹配首尾空格的正则表达式：(^\s*)|(\s*$)

（29） 匹配Email地址的正则表达式：\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*

（30） 匹配网址URL的正则表达式：⁸+://(\w+(-\w+))(\.(\w+(-\w+)))(\?\S)?$

（31） 匹配帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：⁹[a-zA-Z0-9_]{4,15}$

（32） 匹配国内电话号码：(\d{3}-|\d{4}-)?(\d{8}|\d{7})?

（33） 匹配腾讯QQ号：¹⁰[1-9][0-9]$

（34） 元字符及其在正则表达式上下文中的行为：

（35） \ 将下一个字符标记为一个特殊字符、或一个原义字符、或一个后向引用、或一个八进制转义符。

（36） ^ 匹配输入字符串的开始位置。如果设置了 RegExp 对象的Multiline 属性，^ 也匹配 ’\n’ 或 ’\r’ 之后的位置。

（37） $ 匹配输入字符串的结束位置。如果设置了 RegExp 对象的Multiline 属性，$ 也匹配 ’\n’ 或 ’\r’ 之前的位置。

（38） * 匹配前面的子表达式零次或多次。

（39） + 匹配前面的子表达式一次或多次。+ 等价于 {1,}。

（40） ? 匹配前面的子表达式零次或一次。? 等价于 {0,1}。

（41） {n} n 是一个非负整数，匹配确定的n 次。

（42） {n,} n 是一个非负整数，至少匹配n 次。

（43） {n,m} m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。在逗号和两个数之间不能有空格。

（44） ? 当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。

（45） . 匹配除 “\n” 之外的任何单个字符。要匹配包括 ’\n’ 在内的任何字符，请使用象 ’[.\n]’ 的模式。

（46） (pattern) 匹配pattern 并获取这一匹配。

（47） (?:pattern) 匹配pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。

（48） (?=pattern) 正向预查，在任何匹配 pattern 的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。

（49） (?!pattern) 负向预查，与(?=pattern)作用相反

（50） x|y 匹配 x 或 y。

（51） [xyz] 字符集合。

（52） [^xyz] 负值字符集合。

（53） [a-z] 字符范围，匹配指定范围内的任意字符。

（54） [^a-z] 负值字符范围，匹配任何不在指定范围内的任意字符。

（55） \b 匹配一个单词边界，也就是指单词和空格间的位置。

（56） \B 匹配非单词边界。

（57） \cx 匹配由x指明的控制字符。

（58） \d 匹配一个数字字符。等价于 [0-9]。

（59） \D 匹配一个非数字字符。等价于 [^0-9]。

（60） \f 匹配一个换页符。等价于 \x0c 和 \cL。

（61） \n 匹配一个换行符。等价于 \x0a 和 \cJ。

（62） \r 匹配一个回车符。等价于 \x0d 和 \cM。

（63） \s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。

（64） \S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。

（65） \t 匹配一个制表符。等价于 \x09 和 \cI。

（66） \v 匹配一个垂直制表符。等价于 \x0b 和 \cK。

（67） \w 匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’。

（68） \W 匹配任何非单词字符。等价于 ’[^A-Za-z0-9_]’。

（69） \xn 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。

（70） \num 匹配 num，其中num是一个正整数。对所获取的匹配的引用。

（71） \n 标识一个八进制转义值或一个后向引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为后向引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。

（72） \nm 标识一个八进制转义值或一个后向引用。如果 \nm 之前至少有is preceded by at least nm 个获取得子表达式，则 nm 为后向引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的后向引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。

（73） \nml 如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml。

（74） \un 匹配 n，其中 n 是一个用四个十六进制数字表示的Unicode字符。

（75） 匹配中文字符的正则表达式： [u4e00-u9fa5]

（76） 匹配双字节字符(包括汉字在内)：[^x00-xff]

（77） 匹配空行的正则表达式：n[s| ]*r

（78） 匹配HTML标记的正则表达式：/<(.)>.</1>|<(.*) />/

（79） 匹配首尾空格的正则表达式：(^s*)|(s*$)

（80） 匹配Email地址的正则表达式：w+([-+.]w+)@w+([-.]w+).w+([-.]w+)*

（81） 匹配网址URL的正则表达式：http://([w-]+.)+[w-]+(/[w- ./?%&=]*)?

（82） 利用正则表达式限制网页表单里的文本框输入内容：

（83） 用正则表达式限制只能输入中文：οnkeyup=“value=value.replace(/[^u4E00-u9FA5]/g,‘’)” onbeforepaste=“clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^u4E00-u9FA5]/g,‘’))”

（84） 用正则表达式限制只能输入全角字符： οnkeyup=“value=value.replace(/[^uFF00-uFFFF]/g,‘’)” onbeforepaste=“clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^uFF00-uFFFF]/g,‘’))”

（85） 用正则表达式限制只能输入数字：οnkeyup="value=value.replace(/[^d]/g,‘’) "onbeforepaste=“clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^d]/g,‘’))”

（86） 用正则表达式限制只能输入数字和英文：οnkeyup="value=value.replace(/[W]/g,‘’) "onbeforepaste=“clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^d]/g,‘’))”

（87） 整理：

（88） 匹配中文字符的正则表达式： [\u4e00-\u9fa5]

（89） 匹配双字节字符(包括汉字在内)：[^\x00-\xff]

（90） 匹配空行的正则表达式：\n[\s| ]*\r

（91） 匹配HTML标记的正则表达式：/<(.)>.</\1>|<(.*) />/

（92） 匹配首尾空格的正则表达式：(^\s*)|(\s*$)

（93） 匹配IP地址的正则表达式：/(\d+).(\d+).(\d+).(\d+)/g //

（94） 匹配Email地址的正则表达式：\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*

（95） 匹配网址URL的正则表达式：http://(/[\w-]+.)+[\w-]+(/[\w- ./?%&=]*)?

（96） sql语句：^(select|drop|delete|create|update|insert).*$

（97） 非负整数：^\d+$

（98） 正整数：¹¹[1-9][0-9]$

（99） 非正整数：^((-\d+)|(0+))$

（100） 负整数：^-[0-9][1-9][0-9]$

（101） 整数：^-?\d+$

（102） 非负浮点数：^\d+(.\d+)?$

（103） 正浮点数：^((0-9)+.[0-9][1-9][0-9])|([0-9][1-9][0-9].[0-9]+)|([0-9][1-9][0-9]))$

（104） 非正浮点数：^((-\d+.\d+)?)|(0+(.0+)?))$

（105） 负浮点数：^(-((正浮点数正则式)))$

（106） 英文字符串：¹²+$

（107） 英文大写串：¹³+$

（108） 英文小写串：¹⁴+$

（109） 英文字符数字串：¹⁵+$

（110） 英数字加下划线串：^\w+$

（111） E-mail地址：¹⁶+(.[\w-]+)*@[\w-]+(.[\w-]+)+$

（112） URL：¹⁷+://(\w+(-\w+))(.(\w+(-\w+)))(?\s)?$

或：^{http://[A-Za-z0-9]+.[A-Za-z0-9]+[/=?%-&_~`@[]':+!]*([}<>“”])*$

（113） 邮政编码：¹⁸\d{5}$

（114） 中文：¹⁹+$

（115） 电话号码：^((\d2,3\d2,3)|(\d{3}-))?(0\d2,30\d2,3|0\d{2,3}-)?[1-9]\d{6,7}(-\d{1,4})?$

（116） 手机号码：^((\d2,3\d2,3)|(\d{3}-))?13\d{9}$

（117） 双字节字符(包括汉字在内)：^\x00-\xff

（118） 匹配首尾空格：(^\s*)|(\s*$)（像vbscript那样的trim函数）

（119） 匹配HTML标记：<(.)>.</\1>|<(.*) />

（120） 匹配空行：\n[\s| ]*\r

（121） 提取信息中的网络链接：(h|H)(r|R)(e|E)(f|F) *= *(‘|")?(\w|\|/|.)+(’|"| *|>)?

（122） 提取信息中的邮件地址：\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*

（123） 提取信息中的图片链接：(s|S)(r|R)(c|C) *= *(‘|")?(\w|\|/|.)+(’|"| *|>)?

（124） 提取信息中的IP地址：(\d+).(\d+).(\d+).(\d+)

（125） 提取信息中的中国手机号码：(86)013\d{9}

（126） 提取信息中的中国固定电话号码：(\d3,4\d3,4|\d{3,4}-|\s)?\d{8}

（127） 提取信息中的中国电话号码（包括移动和固定电话）：(\d3,4\d3,4|\d{3,4}-|\s)?\d{7,14}

（128） 提取信息中的中国邮政编码：[1-9]{1}(\d+){5}

（129） 提取信息中的浮点数（即小数）：(-?\d*).?\d+

（130） 提取信息中的任何数字 ：(-?\d*)(.\d+)?

（131） IP：(\d+).(\d+).(\d+).(\d+)

（132） 电话区号：/^0\d{2,3}$/

（133） 腾讯QQ号：²⁰[1-9][0-9]$

（134） 帐号(字母开头，允许5-16字节，允许字母数字下划线)：²¹[a-zA-Z0-9_]{4,15}$

（135） 中文、英文、数字及下划线：²²+$

3.Hive

备注：“(双引号) 不用加转义字符

hive语法与java类似，比如会先将‘\\w’编译成‘\w’，然后将其交给正则表达式处理

1.regexp_extract(string subject, string pattern, int index)

regexp_extract(string subject, string pattern, int index)
//返回值：string
//功能：将字符串subject按照pattern正则表达式的规则拆分，返回index指定的字符。

实例一：

场景：在进入到酒店详情页时，想看一下有多少用户会点击“增值税专用发票”这个按钮时，因此需要将埋点表中这个数据解析出来。

数据格式如下，是存在于一个json套json的字段中，如下数据是存放在filterlist字段中：

json : “[{“filtertitle”:”**服务",“filtertype”:“3”,“filtersubtype”:“”,“filtername”:“增值税专用发票”,“filterid”:“3|SpecialInvoiceHotel”}]"

select  regexp_extract(filterlist,'(filtername\\"\\:\\")(\\增\\值\\税\\专\\用\\发\\票)(\\"\\,)',2) as filtername
from AAA

实例二：

场景：在分析用户行为数据时，需要将用户在平台筛选的数据进行解析，但是埋点记录的方式是以json字符串的方式存储的，因此需要将埋点数据解析为结构化的数据形式。清洗出filtertype、filtername、filterid、filtertitle等字段。

数据格式如下：

json: {“filtertype”:“29”,“filtername”:“成人Node”,“filtertitle”:“成人Group”,“filtersubtype”:“”,“filterid”:“29|1”,“filterValue”:“1|4”}
{“filtertitle”:“钻级”,“filtertype”:“16”,“filtersubtype”:“”,“filtername”:“四钻/高档”,“filterid”:“16|4”,}

use dw_HHHHHH;
select clientcode
      ,regexp_extract(filterlist,'(filtertype"\\:")(\\d+)(",)',2)               as filtertype
      ,regexp_extract(filterlist,'(filtername"\\:")((\\W*\\w*)|(\\W*))(",)',2)  as filtername
      ,regexp_extract(filterlist,'(filtertitle"\\:")((\\W*\\w*)|(\\W*))(",)',2) as filtertitle
      ,regexp_extract(filterlist,'(filterid"\\:")(\\d+\\|\\d+)(",)',2)          as filterid
from tmp_action_click



--实际情况
select properties,
regexp_extract(properties,'(\\$city"\\:")((\\W*\\w*)|(\\W*))(",)',2) 
from   jt_tyjrdb.stream_sensors_bybo_hive where dt = '20220612'

2.regexp

做判断用

A REGEXP B
//功能同RLIKE
//如果字符串A或者字符串B为NULL，则返回NULL；如果字符串A符合表达式B 的正则语法，则为TRUE；否则为FALSE。B中字符”_”表示任意单个字符，而字符”%”表示任意数量的字符。

3.regexp_replace(string INITIAL_STRING, string PATTERN, string REPLACEMENT)

返回用替换实例替换INITIAL_STRING中与模式中定义的java正则表达式语法匹配的所有子字符串所产生的字符串。例如，regexp_replace(“foobar”， “oo|ar”， “”)返回’fb。‘注意，在使用预定义字符类时需要注意:使用’\s’作为第二个参数将匹配字母s;’\s’必须匹配空格，等等。

4.Trino

trino能够兼容hive，编译与python类似，与实际上trino可以将json串转为map格式的字段，也能达到正则表达式类似的效果，sql如下：

select
                try(element_at(cast(json_parse(properties) as map(varchar,varchar)),'share_id')) as uacid,
                a.dt
        from
                jt_tyjrdb.stream_sensors_bybo_hive a
                
                
                --实际情况
select properties,
regexp_extract(properties,'\$city"\:"((\W*\w*)|(\w*))\",',1) 
from   jt_tyjrdb.stream_sensors_bybo_hive;                              

函数名	内容
regexp_extract_all(字符串,模式)->数组	返回所有匹配的结果
regexp_extract_all(字符串,模式,组)->数组	返回所有匹配的捕获组中的内容
regexp_extract(字符串,模式) →varchar	返回第一个满足条件的结果
regexp_extract(字符串,模式,组)→varchar	返回第一个满足条件的捕获组中的内容
regexp_like(字符串,模式)→布尔值	计算正则表达式pattern并确定它是否包含在中string
regexp_replace(字符串,模式)→varchar	pattern从中删除与正则表达式匹配的子字符串的每个实例
regexp_replace(字符串,模式,替换)→varchar	通过替换正则表达式匹配的子串的每个实例 pattern中string使用replacement
regexp_split(字符串,模式)->数组r	string使用正则表达式拆分pattern并返回一个数组

---

1. 0-9 ↩︎

2. A-Za-z ↩︎

3. A-Z ↩︎

4. a-z ↩︎

5. A-Za-z0-9 ↩︎

6. \w- ↩︎

7. a-zA-z ↩︎

8. a-zA-z ↩︎

9. a-zA-Z ↩︎

10. 1-9 ↩︎

11. 0-9 ↩︎

12. A-Za-z ↩︎

13. A-Z ↩︎

14. a-z ↩︎

15. A-Za-z0-9 ↩︎

16. \w- ↩︎

17. a-zA-Z ↩︎

18. 1-9 ↩︎

19. \u0391-\uFFE5 ↩︎

20. 1-9 ↩︎

21. a-zA-Z ↩︎

22. \u4e00-\u9fa5_a-zA-Z0-9 ↩︎